Merge branch 'mutex-1' of https://github.com/mannol/toxcore

1 files changed, 158 insertions, 157 deletions

diff --git a/toxav/rtp.c b/toxav/rtp.c
index 328eb676..6eb61a81 100644
--- a/toxav/rtp.c
+++ b/toxav/rtp.c
@@ -70,30 +70,30 @@ RTPHeader *extract_header ( const uint8_t *payload, int length )
         return NULL;
     }
 
-    RTPHeader *_retu = calloc(1, sizeof (RTPHeader));
+    RTPHeader *retu = calloc(1, sizeof (RTPHeader));
 
-    if ( !_retu ) {
+    if ( !retu ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
         return NULL;
     }
 
-    memcpy(&_retu->sequnum, payload, sizeof(_retu->sequnum));
-    _retu->sequnum = ntohs(_retu->sequnum);
+    memcpy(&retu->sequnum, payload, sizeof(retu->sequnum));
+    retu->sequnum = ntohs(retu->sequnum);
 
-    const uint8_t *_it = payload + 2;
+    const uint8_t *it = payload + 2;
 
-    _retu->flags = *_it;
-    ++_it;
+    retu->flags = *it;
+    ++it;
 
     /* This indicates if the first 2 bits are valid.
      * Now it may happen that this is out of order but
      * it cuts down chances of parsing some invalid value
      */
 
-    if ( GET_FLAG_VERSION(_retu) != RTP_VERSION ) {
+    if ( GET_FLAG_VERSION(retu) != RTP_VERSION ) {
         /* Deallocate */
         LOGGER_WARNING("Invalid version!");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
@@ -101,38 +101,38 @@ RTPHeader *extract_header ( const uint8_t *payload, int length )
      * Added a check for the size of the header little sooner so
      * I don't need to parse the other stuff if it's bad
      */
-    uint8_t _cc = GET_FLAG_CSRCC ( _retu );
-    int _length = 12 /* Minimum header len */ + ( _cc * 4 );
+    uint8_t cc = GET_FLAG_CSRCC ( retu );
+    int total = 12 /* Minimum header len */ + ( cc * 4 );
 
-    if ( length < _length ) {
+    if ( length < total ) {
         /* Deallocate */
         LOGGER_WARNING("Length invalid!");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
-    memset(_retu->csrc, 0, 16 * sizeof (uint32_t));
+    memset(retu->csrc, 0, 16 * sizeof (uint32_t));
 
-    _retu->marker_payloadt = *_it;
-    ++_it;
-    _retu->length = _length;
+    retu->marker_payloadt = *it;
+    ++it;
+    retu->length = total;
 
 
-    memcpy(&_retu->timestamp, _it, sizeof(_retu->timestamp));
-    _retu->timestamp = ntohl(_retu->timestamp);
-    _it += 4;
-    memcpy(&_retu->ssrc, _it, sizeof(_retu->ssrc));
-    _retu->ssrc = ntohl(_retu->ssrc);
+    memcpy(&retu->timestamp, it, sizeof(retu->timestamp));
+    retu->timestamp = ntohl(retu->timestamp);
+    it += 4;
+    memcpy(&retu->ssrc, it, sizeof(retu->ssrc));
+    retu->ssrc = ntohl(retu->ssrc);
 
-    uint8_t _x;
+    uint8_t x;
 
-    for ( _x = 0; _x < _cc; _x++ ) {
-        _it += 4;
-        memcpy(&_retu->csrc[_x], _it, sizeof(_retu->csrc[_x]));
-        _retu->csrc[_x] = ntohl(_retu->csrc[_x]);
+    for ( x = 0; x < cc; x++ ) {
+        it += 4;
+        memcpy(&retu->csrc[x], it, sizeof(retu->csrc[x]));
+        retu->csrc[x] = ntohl(retu->csrc[x]);
     }
 
-    return _retu;
+    return retu;
 }
 
 /**
@@ -140,47 +140,47 @@ RTPHeader *extract_header ( const uint8_t *payload, int length )
  */
 RTPExtHeader *extract_ext_header ( const uint8_t *payload, uint16_t length )
 {
-    const uint8_t *_it = payload;
+    const uint8_t *it = payload;
 
-    RTPExtHeader *_retu = calloc(1, sizeof (RTPExtHeader));
+    RTPExtHeader *retu = calloc(1, sizeof (RTPExtHeader));
 
-    if ( !_retu ) {
+    if ( !retu ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
         return NULL;
     }
 
-    uint16_t _ext_length;
-    memcpy(&_ext_length, _it, sizeof(_ext_length));
-    _ext_length = ntohs(_ext_length);
-    _it += 2;
+    uint16_t ext_length;
+    memcpy(&ext_length, it, sizeof(ext_length));
+    ext_length = ntohs(ext_length);
+    it += 2;
 
 
-    if ( length < ( _ext_length * sizeof(uint32_t) ) ) {
+    if ( length < ( ext_length * sizeof(uint32_t) ) ) {
         LOGGER_WARNING("Length invalid!");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
-    _retu->length  = _ext_length;
-    memcpy(&_retu->type, _it, sizeof(_retu->type));
-    _retu->type = ntohs(_retu->type);
-    _it += 2;
+    retu->length  = ext_length;
+    memcpy(&retu->type, it, sizeof(retu->type));
+    retu->type = ntohs(retu->type);
+    it += 2;
 
-    if ( !(_retu->table = calloc(_ext_length, sizeof (uint32_t))) ) {
+    if ( !(retu->table = calloc(ext_length, sizeof (uint32_t))) ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
-    uint16_t _x;
+    uint16_t x;
 
-    for ( _x = 0; _x < _ext_length; _x++ ) {
-        _it += 4;
-        memcpy(&(_retu->table[_x]), _it, sizeof(_retu->table[_x]));
-        _retu->table[_x] = ntohl(_retu->table[_x]);
+    for ( x = 0; x < ext_length; x++ ) {
+        it += 4;
+        memcpy(&(retu->table[x]), it, sizeof(retu->table[x]));
+        retu->table[x] = ntohl(retu->table[x]);
     }
 
-    return _retu;
+    return retu;
 }
 
 /**
@@ -188,8 +188,8 @@ RTPExtHeader *extract_ext_header ( const uint8_t *payload, uint16_t length )
  */
 uint8_t *add_header ( RTPHeader *header, uint8_t *payload )
 {
-    uint8_t _cc = GET_FLAG_CSRCC ( header );
-    uint8_t *_it = payload;
+    uint8_t cc = GET_FLAG_CSRCC ( header );
+    uint8_t *it = payload;
     uint16_t sequnum;
     uint32_t timestamp;
     uint32_t ssrc;
@@ -198,30 +198,30 @@ uint8_t *add_header ( RTPHeader *header, uint8_t *payload )
 
     /* Add sequence number first */
     sequnum = htons(header->sequnum);
-    memcpy(_it, &sequnum, sizeof(sequnum));
-    _it += 2;
+    memcpy(it, &sequnum, sizeof(sequnum));
+    it += 2;
 
-    *_it = header->flags;
-    ++_it;
-    *_it = header->marker_payloadt;
-    ++_it;
+    *it = header->flags;
+    ++it;
+    *it = header->marker_payloadt;
+    ++it;
 
 
     timestamp = htonl(header->timestamp);
-    memcpy(_it, &timestamp, sizeof(timestamp));
-    _it += 4;
+    memcpy(it, &timestamp, sizeof(timestamp));
+    it += 4;
     ssrc = htonl(header->ssrc);
-    memcpy(_it, &ssrc, sizeof(ssrc));
+    memcpy(it, &ssrc, sizeof(ssrc));
 
-    uint8_t _x;
+    uint8_t x;
 
-    for ( _x = 0; _x < _cc; _x++ ) {
-        _it += 4;
-        csrc = htonl(header->csrc[_x]);
-        memcpy(_it, &csrc, sizeof(csrc));
+    for ( x = 0; x < cc; x++ ) {
+        it += 4;
+        csrc = htonl(header->csrc[x]);
+        memcpy(it, &csrc, sizeof(csrc));
     }
 
-    return _it + 4;
+    return it + 4;
 }
 
 /**
@@ -229,29 +229,30 @@ uint8_t *add_header ( RTPHeader *header, uint8_t *payload )
  */
 uint8_t *add_ext_header ( RTPExtHeader *header, uint8_t *payload )
 {
-    uint8_t *_it = payload;
+    uint8_t *it = payload;
     uint16_t length;
     uint16_t type;
     uint32_t entry;
 
     length = htons(header->length);
-    memcpy(_it, &length, sizeof(length));
-    _it += 2;
+    memcpy(it, &length, sizeof(length));
+    it += 2;
     type = htons(header->type);
-    memcpy(_it, &type, sizeof(type));
-    _it -= 2; /* Return to 0 position */
+    memcpy(it, &type, sizeof(type));
+    it -= 2; /* Return to 0 position */
 
     if ( header->table ) {
-        uint16_t _x;
 
-        for ( _x = 0; _x < header->length; _x++ ) {
-            _it += 4;
-            entry = htonl(header->table[_x]);
-            memcpy(_it, &entry, sizeof(entry));
+        uint16_t x;
+
+        for ( x = 0; x < header->length; x++ ) {
+            it += 4;
+            entry = htonl(header->table[x]);
+            memcpy(it, &entry, sizeof(entry));
         }
     }
 
-    return _it + 4;
+    return it + 4;
 }
 
 /**
@@ -259,32 +260,32 @@ uint8_t *add_ext_header ( RTPExtHeader *header, uint8_t *payload )
  */
 RTPHeader *build_header ( RTPSession *session )
 {
-    RTPHeader *_retu = calloc ( 1, sizeof (RTPHeader) );
+    RTPHeader *retu = calloc ( 1, sizeof (RTPHeader) );
 
-    if ( !_retu ) {
+    if ( !retu ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
         return NULL;
     }
 
-    ADD_FLAG_VERSION ( _retu, session->version );
-    ADD_FLAG_PADDING ( _retu, session->padding );
-    ADD_FLAG_EXTENSION ( _retu, session->extension );
-    ADD_FLAG_CSRCC ( _retu, session->cc );
-    ADD_SETTING_MARKER ( _retu, session->marker );
-    ADD_SETTING_PAYLOAD ( _retu, session->payload_type );
+    ADD_FLAG_VERSION ( retu, session->version );
+    ADD_FLAG_PADDING ( retu, session->padding );
+    ADD_FLAG_EXTENSION ( retu, session->extension );
+    ADD_FLAG_CSRCC ( retu, session->cc );
+    ADD_SETTING_MARKER ( retu, session->marker );
+    ADD_SETTING_PAYLOAD ( retu, session->payload_type );
 
-    _retu->sequnum = session->sequnum;
-    _retu->timestamp = current_time_monotonic(); /* milliseconds */
-    _retu->ssrc = session->ssrc;
+    retu->sequnum = session->sequnum;
+    retu->timestamp = current_time_monotonic(); /* milliseconds */
+    retu->ssrc = session->ssrc;
 
     int i;
 
     for ( i = 0; i < session->cc; i++ )
-        _retu->csrc[i] = session->csrc[i];
+        retu->csrc[i] = session->csrc[i];
 
-    _retu->length = 12 /* Minimum header len */ + ( session->cc * size_32 );
+    retu->length = 12 /* Minimum header len */ + ( session->cc * size_32 );
 
-    return _retu;
+    return retu;
 }
 
 
@@ -294,47 +295,47 @@ RTPHeader *build_header ( RTPSession *session )
  */
 RTPMessage *msg_parse ( const uint8_t *data, int length )
 {
-    RTPMessage *_retu = calloc(1, sizeof (RTPMessage));
+    RTPMessage *retu = calloc(1, sizeof (RTPMessage));
 
-    _retu->header = extract_header ( data, length ); /* It allocates memory and all */
+    retu->header = extract_header ( data, length ); /* It allocates memory and all */
 
-    if ( !_retu->header ) {
+    if ( !retu->header ) {
         LOGGER_WARNING("Header failed to extract!");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
-    uint16_t _from_pos = _retu->header->length;
-    _retu->length = length - _from_pos;
+    uint16_t from_pos = retu->header->length;
+    retu->length = length - from_pos;
 
 
 
-    if ( GET_FLAG_EXTENSION ( _retu->header ) ) {
-        _retu->ext_header = extract_ext_header ( data + _from_pos, length );
+    if ( GET_FLAG_EXTENSION ( retu->header ) ) {
+        retu->ext_header = extract_ext_header ( data + from_pos, length );
 
-        if ( _retu->ext_header ) {
-            _retu->length -= ( 4 /* Minimum ext header len */ + _retu->ext_header->length * size_32 );
-            _from_pos += ( 4 /* Minimum ext header len */ + _retu->ext_header->length * size_32 );
+        if ( retu->ext_header ) {
+            retu->length -= ( 4 /* Minimum ext header len */ + retu->ext_header->length * size_32 );
+            from_pos += ( 4 /* Minimum ext header len */ + retu->ext_header->length * size_32 );
         } else { /* Error */
             LOGGER_WARNING("Ext Header failed to extract!");
-            rtp_free_msg(NULL, _retu);
+            rtp_free_msg(NULL, retu);
             return NULL;
         }
     } else {
-        _retu->ext_header = NULL;
+        retu->ext_header = NULL;
     }
 
-    if ( length - _from_pos <= MAX_RTP_SIZE )
-        memcpy ( _retu->data, data + _from_pos, length - _from_pos );
+    if ( length - from_pos <= MAX_RTP_SIZE )
+        memcpy ( retu->data, data + from_pos, length - from_pos );
     else {
         LOGGER_WARNING("Invalid length!");
-        rtp_free_msg(NULL, _retu);
+        rtp_free_msg(NULL, retu);
         return NULL;
     }
 
-    _retu->next = NULL;
+    retu->next = NULL;
 
-    return _retu;
+    return retu;
 }
 
 /**
@@ -342,28 +343,28 @@ RTPMessage *msg_parse ( const uint8_t *data, int length )
  */
 int rtp_handle_packet ( void *object, const uint8_t *data, uint32_t length )
 {
-    RTPSession *_session = object;
-    RTPMessage *_msg;
+    RTPSession *session = object;
+    RTPMessage *msg;
 
-    if ( !_session || length < 13 ) { /* 12 is the minimum length for rtp + desc. byte */
+    if ( !session || length < 13 ) { /* 12 is the minimum length for rtp + desc. byte */
         LOGGER_WARNING("No session or invalid length of received buffer!");
         return -1;
     }
 
-    _msg = msg_parse ( data + 1, length - 1 );
+    msg = msg_parse ( data + 1, length - 1 );
 
-    if ( !_msg ) {
+    if ( !msg ) {
         LOGGER_WARNING("Could not parse message!");
         return -1;
     }
 
     /* Check if message came in late */
-    if ( check_late_message(_session, _msg) < 0 ) { /* Not late */
-        _session->rsequnum = _msg->header->sequnum;
-        _session->timestamp = _msg->header->timestamp;
+    if ( check_late_message(session, msg) < 0 ) { /* Not late */
+        session->rsequnum = msg->header->sequnum;
+        session->timestamp = msg->header->timestamp;
     }
 
-    queue_message(_session, _msg);
+    queue_message(session, msg);
 
     return 0;
 }
@@ -378,30 +379,30 @@ RTPMessage *rtp_new_message ( RTPSession *session, const uint8_t *data, uint32_t
         return NULL;
     }
 
-    uint8_t *_from_pos;
-    RTPMessage *_retu = calloc(1, sizeof (RTPMessage));
+    uint8_t *from_pos;
+    RTPMessage *retu = calloc(1, sizeof (RTPMessage));
 
-    if ( !_retu ) {
+    if ( !retu ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
         return NULL;
     }
 
-    /* Sets header values and copies the extension header in _retu */
-    _retu->header = build_header ( session ); /* It allocates memory and all */
-    _retu->ext_header = session->ext_header;
+    /* Sets header values and copies the extension header in retu */
+    retu->header = build_header ( session ); /* It allocates memory and all */
+    retu->ext_header = session->ext_header;
 
 
-    uint32_t _total_length = length + _retu->header->length + 1;
+    uint32_t total_length = length + retu->header->length + 1;
 
-    _retu->data[0] = session->prefix;
+    retu->data[0] = session->prefix;
 
-    if ( _retu->ext_header ) {
-        _total_length += ( 4 /* Minimum ext header len */ + _retu->ext_header->length * size_32 );
+    if ( retu->ext_header ) {
+        total_length += ( 4 /* Minimum ext header len */ + retu->ext_header->length * size_32 );
 
-        _from_pos = add_header ( _retu->header, _retu->data + 1 );
-        _from_pos = add_ext_header ( _retu->ext_header, _from_pos + 1 );
+        from_pos = add_header ( retu->header, retu->data + 1 );
+        from_pos = add_ext_header ( retu->ext_header, from_pos + 1 );
     } else {
-        _from_pos = add_header ( _retu->header, _retu->data + 1 );
+        from_pos = add_header ( retu->header, retu->data + 1 );
     }
 
     /*
@@ -409,14 +410,14 @@ RTPMessage *rtp_new_message ( RTPSession *session, const uint8_t *data, uint32_t
      * Of course if any
      */
 
-    /* Appends _data on to _retu->_data */
-    memcpy ( _from_pos, data, length );
+    /* Appends data on to retu->data */
+    memcpy ( from_pos, data, length );
 
-    _retu->length = _total_length;
+    retu->length = total_length;
 
-    _retu->next = NULL;
+    retu->next = NULL;
 
-    return _retu;
+    return retu;
 }
 
 
@@ -430,7 +431,7 @@ int rtp_send_msg ( RTPSession *session, Messenger *messenger, const uint8_t *dat
     if ( -1 == send_custom_lossy_packet(messenger, session->dest, msg->data, msg->length) ) {
         LOGGER_WARNING("Failed to send full packet (len: %d)! std error: %s", length, strerror(errno));
         rtp_free_msg ( session, msg );
-        return -1;
+        return rtp_ErrorSending;
     }
 
 
@@ -461,52 +462,52 @@ void rtp_free_msg ( RTPSession *session, RTPMessage *msg )
 
 RTPSession *rtp_new ( int payload_type, Messenger *messenger, int friend_num )
 {
-    RTPSession *_retu = calloc(1, sizeof(RTPSession));
+    RTPSession *retu = calloc(1, sizeof(RTPSession));
 
-    if ( !_retu ) {
+    if ( !retu ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
         return NULL;
     }
 
-    if ( -1 == custom_lossy_packet_registerhandler(messenger, friend_num, payload_type, rtp_handle_packet, _retu)) {
+    if ( -1 == custom_lossy_packet_registerhandler(messenger, friend_num, payload_type, rtp_handle_packet, retu)) {
         LOGGER_ERROR("Error setting custom register handler for rtp session");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
     LOGGER_DEBUG("Registered packet handler: pt: %d; fid: %d", payload_type, friend_num);
 
-    _retu->version   = RTP_VERSION;   /* It's always 2 */
-    _retu->padding   = 0;             /* If some additional data is needed about the packet */
-    _retu->extension = 0;           /* If extension to header is needed */
-    _retu->cc        = 1;           /* Amount of contributors */
-    _retu->csrc      = NULL;        /* Container */
-    _retu->ssrc      = random_int();
-    _retu->marker    = 0;
-    _retu->payload_type = payload_type % 128;
+    retu->version   = RTP_VERSION;   /* It's always 2 */
+    retu->padding   = 0;             /* If some additional data is needed about the packet */
+    retu->extension = 0;           /* If extension to header is needed */
+    retu->cc        = 1;           /* Amount of contributors */
+    retu->csrc      = NULL;        /* Container */
+    retu->ssrc      = random_int();
+    retu->marker    = 0;
+    retu->payload_type = payload_type % 128;
 
-    _retu->dest = friend_num;
+    retu->dest = friend_num;
 
-    _retu->rsequnum = _retu->sequnum = 0;
+    retu->rsequnum = retu->sequnum = 0;
 
-    _retu->ext_header = NULL; /* When needed allocate */
+    retu->ext_header = NULL; /* When needed allocate */
 
 
-    if ( !(_retu->csrc = calloc(1, sizeof (uint32_t))) ) {
+    if ( !(retu->csrc = calloc(1, sizeof (uint32_t))) ) {
         LOGGER_WARNING("Alloc failed! Program might misbehave!");
-        free(_retu);
+        free(retu);
         return NULL;
     }
 
-    _retu->csrc[0] = _retu->ssrc; /* Set my ssrc to the list receive */
+    retu->csrc[0] = retu->ssrc; /* Set my ssrc to the list receive */
 
     /* Also set payload type as prefix */
-    _retu->prefix = payload_type;
+    retu->prefix = payload_type;
 
     /*
      *
      */
-    return _retu;
+    return retu;
 }
 
 void rtp_kill ( RTPSession *session, Messenger *messenger )