From e62ded3a6dfc1203418e3d7a2c936794c4c9ec1c Mon Sep 17 00:00:00 2001 From: mannol Date: Sat, 29 Nov 2014 13:42:19 +0100 Subject: More av cleanup --- toxav/rtp.c | 320 ++++++++++++++++++++++++++++++------------------------------ 1 file changed, 158 insertions(+), 162 deletions(-) (limited to 'toxav/rtp.c') diff --git a/toxav/rtp.c b/toxav/rtp.c index 328eb676..a1969fa6 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,37 @@ 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; - - for ( _x = 0; _x < _cc; _x++ ) { - _it += 4; - memcpy(&_retu->csrc[_x], _it, sizeof(_retu->csrc[_x])); - _retu->csrc[_x] = ntohl(_retu->csrc[_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]); } - return _retu; + return retu; } /** @@ -140,47 +139,46 @@ 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; - - 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]); + 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]); } - return _retu; + return retu; } /** @@ -188,8 +186,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 +196,29 @@ 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, ×tamp, sizeof(timestamp)); - _it += 4; + memcpy(it, ×tamp, sizeof(timestamp)); + it += 4; ssrc = htonl(header->ssrc); - memcpy(_it, &ssrc, sizeof(ssrc)); - - uint8_t _x; + memcpy(it, &ssrc, sizeof(ssrc)); - for ( _x = 0; _x < _cc; _x++ ) { - _it += 4; - csrc = htonl(header->csrc[_x]); - memcpy(_it, &csrc, sizeof(csrc)); + uint8_t x; + 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 +226,29 @@ 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 +256,31 @@ 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 +290,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 +338,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 +374,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 +405,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 +426,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 +457,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 ) -- cgit v1.2.3