Changeset 3932

Show
Ignore:
Timestamp:
11/15/06 18:11:13 (7 years ago)
Author:
ucacsva
Message:

commit_msg_15Nov2006.txt

Location:
common/trunk
Files:
7 modified

Legend:

Unmodified
Added
Removed
  • common/trunk/src/mbus.c

    r3922 r3932  
    306306        mbus_validate(m); 
    307307 
    308     *mb_bufpos = '\0'; 
     308      *mb_bufpos = '\0'; 
    309309        assert((mb_bufpos - mb_buffer) < MBUS_BUF_SIZE); 
    310310        assert(strlen(mb_buffer) < MBUS_BUF_SIZE); 
     
    757757        struct timeval           t; 
    758758        struct mbus_parser      *mp, *mp2; 
     759        fd_set  rfd; 
     760        fd_t    max_fd; 
    759761 
    760762        mbus_validate(m); 
     
    769771            assert(m != NULL); 
    770772                assert(m->s != NULL); 
    771                 udp_fd_zero(); 
    772                 udp_fd_set(m->s); 
     773                udp_fd_zero( &rfd, &max_fd); 
     774                udp_fd_set( &rfd, &max_fd, m->s); 
    773775                t.tv_sec  = timeout->tv_sec; 
    774776                t.tv_usec = timeout->tv_usec; 
    775                 if ((udp_select(&t) > 0) && udp_fd_isset(m->s)) { 
     777                if ((udp_select( &rfd, max_fd, &t) > 0) &&  
     778                    udp_fd_isset( &rfd, &max_fd, m->s)) { 
    776779                        buffer_len = udp_recv(m->s, buffer, MBUS_BUF_SIZE); 
    777780                        if (buffer_len > 0) { 
  • common/trunk/src/net_udp.c

    r3922 r3932  
    260260} 
    261261 
     262uint32_t    udp_socket_addr4(socket_udp *s) 
     263{ 
     264  if (s == NULL) { 
     265    return 0; 
     266  } 
     267 
     268  if (s->mode != IPv4) { 
     269    return 0; 
     270  } 
     271 
     272  return (uint32_t)(s->addr4.s_addr);   
     273} 
     274 
     275uint16_t    udp_socket_txport(socket_udp *s) 
     276{ 
     277        if (s == NULL) { 
     278                return 0; 
     279        } 
     280 
     281        return s->tx_port; 
     282} 
     283 
     284int udp_socket_ttl(socket_udp *s) 
     285{ 
     286        if (s == NULL) { 
     287                return -1; 
     288        } 
     289 
     290        return s->ttl; 
     291} 
     292 
    262293static socket_udp *udp_init4(const char *addr, const char *iface, uint16_t rx_port, uint16_t tx_port, int ttl) 
    263294{ 
     
    388419        assert(buflen > 0); 
    389420         
     421        memset(&s_in, 0, sizeof(struct sockaddr_in)); 
    390422        s_in.sin_family      = AF_INET; 
    391423        s_in.sin_addr.s_addr = s->addr4.s_addr; 
     
    9831015} 
    9841016 
    985 static fd_set   rfd; 
    986 static fd_t     max_fd; 
    987  
    9881017/** 
    9891018 * udp_fd_zero: 
     
    9921021 *  
    9931022 **/ 
    994 void udp_fd_zero(void) 
    995 { 
    996         FD_ZERO(&rfd); 
    997         max_fd = 0; 
     1023void udp_fd_zero( fd_set *readset, fd_t *max_fd ) 
     1024{ 
     1025        FD_ZERO(readset); 
     1026        *max_fd = 0; 
    9981027} 
    9991028 
     
    10041033 * Adds file descriptor associated of @s to set associated with UDP sessions. 
    10051034 **/ 
    1006 void udp_fd_set(socket_udp *s) 
    1007 { 
    1008         FD_SET(s->fd, &rfd); 
    1009         if (s->fd > (fd_t)max_fd) { 
    1010                 max_fd = s->fd; 
     1035void udp_fd_set( fd_set *readset, fd_t *max_fd, socket_udp *s) 
     1036{ 
     1037        FD_SET(s->fd, readset); 
     1038        if (s->fd > (fd_t)*max_fd) { 
     1039                *max_fd = s->fd; 
    10111040        } 
    10121041} 
     
    10211050 * Returns: non-zero if set, zero otherwise. 
    10221051 **/ 
    1023 int udp_fd_isset(socket_udp *s) 
    1024 { 
    1025         return FD_ISSET(s->fd, &rfd); 
     1052int udp_fd_isset( fd_set *readset, fd_t *max_fd, socket_udp *s) 
     1053{ 
     1054        UNUSED(max_fd); 
     1055 
     1056        return FD_ISSET(s->fd, readset); 
    10261057} 
    10271058 
     
    10341065 * Return value: number of UDP sessions ready for reading. 
    10351066 **/ 
    1036 int udp_select(struct timeval *timeout) 
    1037 { 
    1038         return select(max_fd + 1, &rfd, NULL, NULL, timeout); 
     1067int udp_select( fd_set *readset, fd_t max_fd, struct timeval *timeout) 
     1068{ 
     1069        return select(max_fd + 1, readset, NULL, NULL, timeout); 
    10391070} 
    10401071 
  • common/trunk/src/net_udp.h

    r641 r3932  
    5454#endif 
    5555 
     56uint32_t    udp_socket_addr4(socket_udp *s); 
     57uint16_t    udp_socket_txport(socket_udp *s); 
     58int         udp_socket_ttl(socket_udp *s); 
     59 
    5660const char *udp_host_addr(socket_udp *s); 
    5761int         udp_fd(socket_udp *s); 
    5862 
    59 int         udp_select(struct timeval *timeout); 
    60 void        udp_fd_zero(void); 
    61 void        udp_fd_set(socket_udp *s); 
    62 int         udp_fd_isset(socket_udp *s); 
     63int         udp_select( fd_set *readset, int max_fd, struct timeval *timeout); 
     64void        udp_fd_zero( fd_set *readset, int *max_fd ); 
     65void        udp_fd_set( fd_set *readset, int *max_fd, socket_udp *s); 
     66int         udp_fd_isset( fd_set *readset, int *max_fd, socket_udp *s); 
    6367 
    6468#if defined(__cplusplus) 
  • common/trunk/src/rtp.c

    r3922 r3932  
    4848 
    4949#include <stddef.h> 
     50 
    5051#include "config_unix.h" 
    5152#include "config_win32.h" 
     
    274275}; 
    275276 
     277 
    276278static inline int  
    277279filter_event(struct rtp *session, uint32_t ssrc) 
     
    910912        pwent = getpwuid(getuid()); 
    911913        if (pwent != NULL) { 
    912         uname = pwent->pw_name; 
    913         } 
    914         if (uname != NULL) { 
    915                 strncpy(cname, uname, MAXCNAMELEN - 1); 
    916                 strcat(cname, "@"); 
    917         } 
    918  
     914                uname = pwent->pw_name; 
     915                if (uname != NULL) { 
     916                        strncpy(cname, uname, MAXCNAMELEN - 1); 
     917                        strcat(cname, "@"); 
     918                } 
     919        } else { 
     920                strncpy(cname, "nobody@", MAXCNAMELEN - 1); 
     921        } 
    919922#endif 
    920923         
     
    10391042        if (rx_port % 2) { 
    10401043                debug_msg("rx_port should be even\n"); 
    1041         } 
     1044        } 
    10421045        if (tx_port % 2) { 
    10431046                debug_msg("tx_port should be even\n"); 
    1044         } 
     1047        } 
    10451048 
    10461049        session                 = (struct rtp *) xmalloc(sizeof(struct rtp)); 
     
    12631266        struct timeval   event_ts; 
    12641267 
    1265         if (packet->fields.cc > 0) { 
    1266                 for (i = 0; i < packet->fields.cc; i++) { 
    1267                         create_source(session, packet->meta.csrc[i], FALSE); 
     1268        if (packet->fields.cc > 0) { 
     1269                for (i = 0; i < packet->fields.cc; i++) { 
     1270                        create_source(session, packet->meta.csrc[i], FALSE); 
    12681271                } 
    12691272        } 
     
    12731276                session->sender_count++; 
    12741277        } 
    1275         transit    = curr_rtp_ts - packet->fields.ts; 
     1278        transit    = curr_rtp_ts - packet->fields.ts; 
    12761279        d          = transit - s->transit; 
    12771280        s->transit = transit; 
     
    12821285         
    12831286        /* Callback to the application to process the packet... */ 
    1284         if (!filter_event(session, packet->fields.ssrc)) { 
     1287        if (!filter_event(session, packet->fields.ssrc)) { 
    12851288                gettimeofday(&event_ts, NULL); 
    1286                 event.ssrc = packet->fields.ssrc; 
     1289                event.ssrc = packet->fields.ssrc; 
    12871290                event.type = RX_RTP; 
    12881291                event.data = (void *) packet;   /* The callback function MUST free this! */ 
     
    12961299        /* Check for valid payload types..... 72-76 are RTCP payload type numbers, with */ 
    12971300        /* the high bit missing so we report that someone is running on the wrong port. */ 
    1298     if (packet->fields.pt >= 72 && packet->fields.pt <= 76) { 
     1301        if (packet->fields.pt >= 72 && packet->fields.pt <= 76) { 
    12991302                debug_msg("rtp_header_validation: payload-type invalid"); 
    1300         if (packet->fields.m) { 
     1303                if (packet->fields.m) { 
    13011304                        debug_msg(" (RTCP packet on RTP port?)"); 
    13021305                } 
     
    13071310 
    13081311        /* Check that the length of the packet is sensible... */ 
    1309         if (len < (12 + (4 * packet->fields.cc))) { 
     1312        if (len < (12 + (4 * packet->fields.cc))) { 
    13101313                debug_msg("rtp_header_validation: packet length is smaller than the header\n"); 
    13111314                return FALSE; 
     
    13131316        /* Check that the amount of padding specified is sensible. */ 
    13141317        /* Note: have to include the size of any extension header! */ 
    1315         if (packet->fields.p) { 
    1316                 int     payload_len = len - 12 - (packet->fields.cc * 4); 
     1318        if (packet->fields.p) { 
     1319                int     payload_len = len - 12 - (packet->fields.cc * 4); 
    13171320                if (packet->fields.x) { 
    13181321                        /* extension header and data */ 
     
    13271330                        return FALSE; 
    13281331                } 
    1329         } 
     1332        } 
    13301333        return TRUE; 
    13311334} 
     
    13411344 
    13421345        /* We only accept RTPv2 packets... */ 
    1343         if (packet->fields.v != 2) { 
     1346        if (packet->fields.v != 2) { 
    13441347                debug_msg("rtp_header_validation: v != 2\n"); 
    13451348                return FALSE; 
     
    13531356{ 
    13541357        /* This routine preprocesses an incoming RTP packet, deciding whether to process it. */ 
    1355         static rtp_packet       *packet   = NULL; 
    1356         static unsigned char            *buffer   = NULL; 
    1357         static unsigned char            *buffer12 = NULL; 
     1358        rtp_packet      *packet   = NULL; 
     1359        uint8_t         *buffer   = NULL; 
     1360        uint8_t         *buffer12 = NULL; 
    13581361        int                      buflen; 
    13591362        source                  *s; 
     
    13621365                packet   = (rtp_packet *) xmalloc(RTP_MAX_PACKET_LEN); 
    13631366                buffer   = ((unsigned char *) packet) + offsetof(rtp_packet, fields); 
    1364                 buffer12 = buffer + 12; 
    1365         } 
    1366  
     1367        buffer12 = buffer + 12; 
     1368        } 
     1369         
    13671370        buflen = udp_recv(session->rtp_socket, (char *)buffer, RTP_MAX_PACKET_LEN - offsetof(rtp_packet, fields)); 
    13681371        if (buflen > 0) { 
     
    13721375                } 
    13731376                /* Convert header fields to host byte order... */ 
    1374                 packet->fields.seq      = ntohs(packet->fields.seq); 
    1375                 packet->fields.ts       = ntohl(packet->fields.ts); 
    1376                 packet->fields.ssrc     = ntohl(packet->fields.ssrc); 
     1377                packet->fields.seq      = ntohs(packet->fields.seq); 
     1378                packet->fields.ts       = ntohl(packet->fields.ts); 
     1379                packet->fields.ssrc     = ntohl(packet->fields.ssrc); 
    13771380                /* Setup internal pointers, etc... */ 
    1378                 if (packet->fields.cc) { 
     1381                if (packet->fields.cc) { 
    13791382                        int     i; 
    1380                         packet->meta.csrc = (uint32_t *)(buffer12); 
    1381                         for (i = 0; i < packet->fields.cc; i++) { 
     1383                        packet->meta.csrc = (uint32_t *)(buffer12); 
     1384                        for (i = 0; i < packet->fields.cc; i++) { 
    13821385                                packet->meta.csrc[i] = ntohl(packet->meta.csrc[i]); 
    13831386                        } 
    13841387                } else { 
    1385                         packet->meta.csrc = NULL; 
    1386                 } 
    1387                 if (packet->fields.x) { 
    1388                         packet->meta.extn      = buffer12 + (packet->fields.cc * 4); 
    1389                         packet->meta.extn_len  = (packet->meta.extn[2] << 8) | packet->meta.extn[3]; 
    1390                         packet->meta.extn_type = (packet->meta.extn[0] << 8) | packet->meta.extn[1]; 
     1388                        packet->meta.csrc = NULL; 
     1389                } 
     1390                if (packet->fields.x) { 
     1391                        packet->meta.extn      = buffer12 + (packet->fields.cc * 4); 
     1392                        packet->meta.extn_len  = (packet->meta.extn[2] << 8) | packet->meta.extn[3]; 
     1393                        packet->meta.extn_type = (packet->meta.extn[0] << 8) | packet->meta.extn[1]; 
    13911394                } else { 
    1392                         packet->meta.extn      = NULL; 
    1393                         packet->meta.extn_len  = 0; 
    1394                         packet->meta.extn_type = 0; 
     1395                        packet->meta.extn      = NULL; 
     1396                        packet->meta.extn_len  = 0; 
     1397                        packet->meta.extn_type = 0; 
    13951398                } 
    13961399                packet->meta.data     = (char *) buffer12 + (packet->fields.cc * 4); 
    1397                 packet->meta.data_len = buflen -  (packet->fields.cc * 4) - 12; 
    1398                 if (packet->meta.extn != NULL) { 
    1399                         packet->meta.data += ((packet->meta.extn_len + 1) * 4); 
    1400                         packet->meta.data_len -= ((packet->meta.extn_len + 1) * 4); 
     1400                packet->meta.data_len = buflen -  (packet->fields.cc * 4) - 12; 
     1401                if (packet->meta.extn != NULL) { 
     1402                        packet->meta.data += ((packet->meta.extn_len + 1) * 4); 
     1403                        packet->meta.data_len -= ((packet->meta.extn_len + 1) * 4); 
    14011404                } 
    14021405                if (validate_rtp(session, packet, buflen)) { 
    14031406                        if (session->opt->wait_for_rtcp) { 
    1404                                 s = create_source(session, packet->fields.ssrc, TRUE); 
     1407                                s = create_source(session, packet->fields.ssrc, TRUE); 
    14051408                        } else { 
    1406                                 s = get_source(session, packet->fields.ssrc); 
     1409                                s = get_source(session, packet->fields.ssrc); 
    14071410                        } 
    14081411                        if (session->opt->promiscuous_mode) { 
    14091412                                if (s == NULL) { 
    1410                                         create_source(session, packet->fields.ssrc, FALSE); 
    1411                                         s = get_source(session, packet->fields.ssrc); 
     1413                                        create_source(session, packet->fields.ssrc, FALSE); 
     1414                                        s = get_source(session, packet->fields.ssrc); 
    14121415                                } 
    14131416                                process_rtp(session, curr_rtp_ts, packet, s); 
     
    14171420                                if (s->probation == -1) { 
    14181421                                        s->probation = MIN_SEQUENTIAL; 
    1419                                         s->max_seq   = packet->fields.seq - 1; 
     1422                                        s->max_seq   = packet->fields.seq - 1; 
    14201423                                } 
    1421                                 if (update_seq(s, packet->fields.seq)) { 
     1424                                if (update_seq(s, packet->fields.seq)) { 
    14221425                                        process_rtp(session, curr_rtp_ts, packet, s); 
    14231426                                        return; /* we don't free "packet", that's done by the callback function... */ 
     
    18741877int rtp_recv(struct rtp *session, struct timeval *timeout, uint32_t curr_rtp_ts) 
    18751878{ 
    1876         check_database(session); 
    1877         udp_fd_zero(); 
    1878         udp_fd_set(session->rtp_socket); 
    1879         udp_fd_set(session->rtcp_socket); 
    1880         if (udp_select(timeout) > 0) { 
    1881                 if (udp_fd_isset(session->rtp_socket)) { 
     1879        fd_set  rfd; 
     1880        fd_t    max_fd; 
     1881        check_database(session); 
     1882 
     1883        udp_fd_zero( &rfd, &max_fd ); 
     1884        udp_fd_set( &rfd, &max_fd, session->rtp_socket); 
     1885        udp_fd_set( &rfd, &max_fd, session->rtcp_socket); 
     1886        if (udp_select( &rfd, max_fd, timeout) > 0) { 
     1887                if (udp_fd_isset( &rfd, &max_fd, session->rtp_socket)) { 
    18821888                        rtp_recv_data(session, curr_rtp_ts); 
    18831889                } 
    1884                 if (udp_fd_isset(session->rtcp_socket)) { 
    1885                         char          buffer[RTP_MAX_PACKET_LEN]; 
     1890                if (udp_fd_isset( &rfd, &max_fd, session->rtcp_socket)) { 
     1891                        uint8_t          buffer[RTP_MAX_PACKET_LEN]; 
    18861892                        int              buflen; 
    1887                         buflen = udp_recv(session->rtcp_socket, buffer, RTP_MAX_PACKET_LEN); 
     1893                        buflen = udp_recv(session->rtcp_socket, (char *)buffer, RTP_MAX_PACKET_LEN); 
    18881894                        rtp_process_ctrl(session, (unsigned char *)buffer, buflen); 
    18891895                } 
     
    22002206 
    22012207        /* These are internal pointers into the buffer... */ 
    2202         packet->meta.csrc = (uint32_t *) (buffer + offsetof(rtp_packet, fields) + 12); 
    2203         packet->meta.extn = (uint8_t  *) (buffer + offsetof(rtp_packet, fields) + 12 + (4 * cc)); 
     2208        packet->meta.csrc = (uint32_t *) (buffer + offsetof(rtp_packet, fields) + 12); 
     2209        packet->meta.extn = (uint8_t  *) (buffer + offsetof(rtp_packet, fields) + 12 + (4 * cc)); 
    22042210        packet->meta.data = (char  *) (buffer + offsetof(rtp_packet, fields) + 12 + (4 * cc)); 
    22052211        if (extn != NULL) { 
    2206                 packet->meta.data += (extn_len + 1) * 4; 
     2212                packet->meta.data += (extn_len + 1) * 4; 
    22072213        } 
    22082214        /* ...and the actual packet header... */ 
    2209         packet->fields.v    = 2; 
    2210         packet->fields.p    = pad; 
    2211         packet->fields.x    = (extn != NULL); 
    2212         packet->fields.cc   = cc; 
    2213         packet->fields.m    = m; 
    2214         packet->fields.pt   = pt; 
    2215         packet->fields.seq  = htons(session->rtp_seq++); 
    2216         packet->fields.ts   = htonl(rtp_ts); 
    2217         packet->fields.ssrc = htonl(rtp_my_ssrc(session)); 
     2215        packet->fields.v    = 2; 
     2216        packet->fields.p    = pad; 
     2217        packet->fields.x    = (extn != NULL); 
     2218        packet->fields.cc   = cc; 
     2219        packet->fields.m    = m; 
     2220        packet->fields.pt   = pt; 
     2221        packet->fields.seq  = htons(session->rtp_seq++); 
     2222        packet->fields.ts   = htonl(rtp_ts); 
     2223        packet->fields.ssrc = htonl(rtp_my_ssrc(session)); 
    22182224        /* ...now the CSRC list... */ 
    22192225        for (i = 0; i < cc; i++) { 
    2220                 packet->meta.csrc[i] = htonl(csrc[i]); 
     2226                packet->meta.csrc[i] = htonl(csrc[i]); 
    22212227        } 
    22222228        /* ...a header extension? */ 
    22232229        if (extn != NULL) { 
    22242230                /* We don't use the packet->fields.extn_type field here, that's for receive only... */ 
    2225                 uint16_t *base = (uint16_t *) packet->meta.extn; 
     2231                uint16_t *base = (uint16_t *) packet->meta.extn; 
    22262232                base[0] = htons(extn_type); 
    22272233                base[1] = htons(extn_len); 
    2228                 memcpy(packet->meta.extn + 4, extn, extn_len * 4); 
     2234                memcpy(packet->meta.extn + 4, extn, extn_len * 4); 
    22292235        } 
    22302236        /* ...and the media data... */ 
    2231         memcpy(packet->meta.data, data, data_len); 
     2237        memcpy(packet->meta.data, data, data_len); 
    22322238        /* ...and any padding... */ 
    22332239        if (pad) { 
    22342240                for (i = 0; i < pad_len; i++) { 
    2235                         buffer[buffer_len + offsetof(rtp_packet, fields) - pad_len + i] = 0; 
    2236                 } 
    2237                 buffer[buffer_len + offsetof(rtp_packet, fields) - 1] = (char) pad_len; 
     2241                        buffer[buffer_len + offsetof(rtp_packet, fields) - pad_len + i] = 0; 
     2242                } 
     2243                buffer[buffer_len + offsetof(rtp_packet, fields) - 1] = (char) pad_len; 
    22382244        } 
    22392245         
     
    22462252        } 
    22472253 
    2248         rc = udp_send(session->rtp_socket, buffer + offsetof(rtp_packet, fields), buffer_len); 
     2254          rc = udp_send(session->rtp_socket, buffer + offsetof(rtp_packet, fields), buffer_len); 
    22492255        xfree(buffer); 
    22502256 
     
    22852291 
    22862292        /* These are internal pointers into the buffer... */ 
    2287         packet->meta.csrc = (uint32_t *) (buffer + offsetof(rtp_packet, fields) + 12); 
    2288         packet->meta.extn = (uint8_t  *) (buffer + offsetof(rtp_packet, fields) + 12 + (4 * cc)); 
     2293        packet->meta.csrc = (uint32_t *) (buffer + offsetof(rtp_packet, fields) + 12); 
     2294        packet->meta.extn = (uint8_t  *) (buffer + offsetof(rtp_packet, fields) + 12 + (4 * cc)); 
    22892295        packet->meta.data = (char  *) (buffer + offsetof(rtp_packet, fields) + 12 + (4 * cc)); 
    22902296        if (extn != NULL) { 
    2291                 packet->meta.data += (extn_len + 1) * 4; 
     2297                packet->meta.data += (extn_len + 1) * 4; 
    22922298        } 
    22932299        /* ...and the actual packet header... */ 
    2294         packet->fields.v    = 2; 
    2295         packet->fields.p    = 0; 
    2296         packet->fields.x    = (extn != NULL); 
    2297         packet->fields.cc   = cc; 
    2298         packet->fields.m    = m; 
    2299         packet->fields.pt   = pt; 
    2300         packet->fields.seq  = htons(session->rtp_seq++); 
    2301         packet->fields.ts   = htonl(rtp_ts); 
    2302         packet->fields.ssrc = htonl(rtp_my_ssrc(session)); 
     2300        packet->fields.v    = 2; 
     2301        packet->fields.p    = 0; 
     2302        packet->fields.x    = (extn != NULL); 
     2303        packet->fields.cc   = cc; 
     2304        packet->fields.m    = m; 
     2305        packet->fields.pt   = pt; 
     2306        packet->fields.seq  = htons(session->rtp_seq++); 
     2307        packet->fields.ts   = htonl(rtp_ts); 
     2308        packet->fields.ssrc = htonl(rtp_my_ssrc(session)); 
    23032309        /* ...now the CSRC list... */ 
    23042310        for (i = 0; i < cc; i++) { 
    2305                 packet->meta.csrc[i] = htonl(csrc[i]); 
     2311                packet->meta.csrc[i] = htonl(csrc[i]); 
    23062312        } 
    23072313        /* ...a header extension? */ 
    23082314        if (extn != NULL) { 
    23092315                /* We don't use the packet->fields.extn_type field here, that's for receive only... */ 
    2310                 uint16_t *base = (uint16_t *) packet->meta.extn; 
     2316                uint16_t *base = (uint16_t *) packet->meta.extn; 
    23112317                base[0] = htons(extn_type); 
    23122318                base[1] = htons(extn_len); 
    2313                 memcpy(packet->meta.extn + 4, extn, extn_len * 4); 
     2319                memcpy(packet->meta.extn + 4, extn, extn_len * 4); 
    23142320        } 
    23152321 
     
    23172323        my_iov = (struct iovec*)xmalloc(my_iov_count * sizeof(struct iovec)); 
    23182324 
    2319         my_iov[0].iov_base = buffer + offsetof(rtp_packet, fields); 
     2325        my_iov[0].iov_base = buffer + offsetof(rtp_packet, fields); 
    23202326        my_iov[0].iov_len = buffer_len; 
    23212327 
     
    25852591 
    25862592        /* Copy one APP packet from "app" to "packet". */ 
    2587         packet->version        =   RTP_VERSION; 
    2588         packet->p              =   app->p; 
    2589         packet->subtype        =   app->subtype; 
    2590         packet->pt             =   RTCP_APP; 
    2591         packet->length         =   htons(app->length); 
    2592         packet->ssrc           =   htonl(ssrc); 
     2593        packet->version =   RTP_VERSION; 
     2594        packet->p       =   app->p; 
     2595        packet->subtype =   app->subtype; 
     2596        packet->pt      =   RTCP_APP; 
     2597        packet->length  =   htons(app->length); 
     2598        packet->ssrc    =   htonl(ssrc); 
    25932599        memcpy(packet->name, app->name, 4); 
    25942600        memcpy(packet->data, app->data, data_octets); 
     
    28952901        int             buflen; 
    28962902        double          new_interval; 
     2903        fd_set  rfd; 
     2904        fd_t    max_fd; 
     2905 
    28972906 
    28982907        check_database(session); 
     
    29292938                        timeout.tv_usec = 0; 
    29302939                        tv_add(&timeout, tv_diff(session->next_rtcp_send_time, curr_time)); 
    2931                         udp_fd_zero(); 
    2932                         udp_fd_set(session->rtcp_socket); 
    2933                         if ((udp_select(&timeout) > 0) && udp_fd_isset(session->rtcp_socket)) { 
     2940                        udp_fd_zero( &rfd, &max_fd ); 
     2941                        udp_fd_set( &rfd, &max_fd, session->rtcp_socket); 
     2942                        if ((udp_select(&rfd, max_fd, &timeout) > 0) && udp_fd_isset( &rfd, &max_fd, session->rtcp_socket)) { 
    29342943                                /* We woke up because an RTCP packet was received; process it... */ 
    2935                                 buflen = udp_recv(session->rtcp_socket, (char *) buffer, RTP_MAX_PACKET_LEN); 
     2944                                buflen = udp_recv(session->rtcp_socket, (char *)buffer, RTP_MAX_PACKET_LEN); 
    29362945                                rtp_process_ctrl(session, buffer, buflen); 
    29372946                        } 
     
    30933102        MD5Update(&context, (u_char *) canonical_passphrase, strlen(canonical_passphrase)); 
    30943103        MD5Final((u_char *) hash, &context); 
    3095      
     3104 
    30963105        /* Initialize the encryption algorithm we've received */ 
    30973106 
  • common/trunk/src/rtp.h

    r690 r3932  
    6262        /* WARNING: Don't change the size of the first portion of the */ 
    6363        /* struct without changing RTP_PACKET_HEADER_SIZE to match.   */ 
    64     struct _meta { 
     64  struct _meta { 
    6565        uint32_t        *csrc; 
    6666        char            *data; 
     
    6969        uint16_t         extn_len;      /* Size of the extension in 32 bit words minus one */ 
    7070        uint16_t         extn_type;     /* Extension type field in the RTP packet header   */ 
    71     } meta; 
     71  } meta; 
    7272 
    7373    struct _fields { 
     
    205205                            uint8_t *userdata); 
    206206 
     207int              rtp_set_umtp_dest(struct rtp *session, 
     208                                   const char *addr, 
     209                                   uint16_t port, 
     210                                   uint16_t src_cookie, 
     211                                   uint16_t dst_cookie); 
     212 
    207213void             rtp_send_bye(struct rtp *session); 
    208214void             rtp_done(struct rtp *session); 
     
    250256uint8_t         *rtp_get_userdata(struct rtp *session); 
    251257 
     258int             rtp_get_ssrc_count(struct rtp *session); 
     259 
    252260#endif /* __RTP_H__ */ 
  • common/trunk/src/sap.c

    r3922 r3932  
    9797  sap_header *sap_h; 
    9898  static unsigned char *packetptr; 
     99  fd_set rfd; 
     100  fd_t   max_fd; 
    99101 
    100   udp_fd_zero(); 
    101   udp_fd_set(s->s); 
    102   if(udp_select(timeout) > 0) { 
    103     if(udp_fd_isset(s->s)) { 
     102  udp_fd_zero( &rfd, &max_fd ); 
     103  udp_fd_set( &rfd, &max_fd, s->s); 
     104  if(udp_select( &rfd, max_fd, timeout) > 0) { 
     105    if(udp_fd_isset( &rfd, &max_fd, s->s)) { 
    104106      uint8_t buffer[SAP_MAX_PACKET_LEN]; 
    105107      int     buflen; 
  • common/trunk/tests/test_net_udp.c

    r514 r3932  
    5858        const char      *hname; 
    5959        int              rc, i; 
     60        fd_set           rfd; 
     61        fd_t             max_fd; 
     62 
    6063         
    6164#ifndef WIN32 
     
    8891        timeout.tv_sec  = 1; 
    8992        timeout.tv_usec = 0; 
    90         udp_fd_zero(); 
    91         udp_fd_set(s1); 
    92         rc = udp_select(&timeout); 
     93        udp_fd_zero( &rfd, &max_fd ); 
     94        udp_fd_set( &rfd, &max_fd, s1 ); 
     95        rc = udp_select(&rfd, max_fd, &timeout); 
    9396        if (rc < 0) { 
    9497                perror("fail"); 
     
    99102                goto abort_loopback; 
    100103        } 
    101         if (!udp_fd_isset(s1)) { 
     104        if (!udp_fd_isset(&rfd, &max_fd, s1)) { 
    102105                printf("fail: no data on file descriptor\n"); 
    103106                goto abort_loopback; 
     
    139142        timeout.tv_sec  = 1; 
    140143        timeout.tv_usec = 0; 
    141         udp_fd_zero(); 
    142         udp_fd_set(s1); 
    143         udp_fd_set(s2); 
    144         rc = udp_select(&timeout); 
     144        udp_fd_zero( &rfd, &max_fd ); 
     145        udp_fd_set( &rfd, &max_fd, s1 ); 
     146        udp_fd_set( &rfd, &max_fd, s2 ); 
     147        rc = udp_select(&rfd, max_fd, &timeout); 
    145148        if (rc < 0) { 
    146149                perror("fail"); 
     
    151154                goto abort_unicast; 
    152155        } 
    153         if (!udp_fd_isset(s2)) { 
     156        if (!udp_fd_isset(&rfd, &max_fd, s2)) { 
    154157                printf("fail: no data on file descriptor\n"); 
    155158                goto abort_unicast; 
     
    184187        timeout.tv_sec  = 1; 
    185188        timeout.tv_usec = 0; 
    186         udp_fd_zero(); 
    187         udp_fd_set(s1); 
    188         rc = udp_select(&timeout); 
     189        udp_fd_zero( &rfd, &max_fd ); 
     190        udp_fd_set( &rfd, &max_fd, s1 ); 
     191        rc = udp_select(&rfd, max_fd, &timeout); 
    189192        if (rc < 0) { 
    190193                perror("fail"); 
     
    195198                goto abort_multicast; 
    196199        } 
    197         if (!udp_fd_isset(s1)) { 
     200        if (!udp_fd_isset(&rfd, &max_fd, s1)) { 
    198201                printf("fail: no data on file descriptor\n"); 
    199202                goto abort_multicast; 
     
    228231                timeout.tv_sec  = 1; 
    229232                timeout.tv_usec = 0; 
    230                 udp_fd_zero(); 
    231                 udp_fd_set(s1); 
    232                 rc = udp_select(&timeout); 
     233                udp_fd_zero( &rfd, &max_fd ); 
     234                udp_fd_set( &rfd, &max_fd, s1 ); 
     235                rc = udp_select(&rfd, max_fd, &timeout); 
    233236                if (rc < 0) { 
    234237                        perror("fail"); 
     
    239242                        goto abort_length; 
    240243                } 
    241                 if (!udp_fd_isset(s1)) { 
     244                if (!udp_fd_isset(&rfd, &max_fd, s1)) { 
    242245                        printf("fail: no data on file descriptor\n"); 
    243246                        goto abort_length; 
     
    275278        timeout.tv_sec  = 1; 
    276279        timeout.tv_usec = 0; 
    277         udp_fd_zero(); 
    278         udp_fd_set(s1); 
    279         rc = udp_select(&timeout); 
     280        udp_fd_zero( &rfd, &max_fd ); 
     281        udp_fd_set( &rfd, &max_fd, s1 ); 
     282        rc = udp_select(&rfd, max_fd, &timeout); 
    280283        if (rc < 0) { 
    281284                perror("fail"); 
     
    286289                goto abort_loopback_ipv6; 
    287290        } 
    288         if (!udp_fd_isset(s1)) { 
     291        if (!udp_fd_isset(&rfd, &max_fd, s1)) { 
    289292                printf("fail: no data on file descriptor\n"); 
    290293                goto abort_loopback_ipv6; 
     
    319322        timeout.tv_sec  = 1; 
    320323        timeout.tv_usec = 0; 
    321         udp_fd_zero(); 
    322         udp_fd_set(s1); 
    323         rc = udp_select(&timeout); 
     324        udp_fd_zero( &rfd, &max_fd ); 
     325        udp_fd_set( &rfd, &max_fd, s1 ); 
     326        rc = udp_select(&rfd, max_fd, &timeout); 
    324327        if (rc < 0) { 
    325328                perror("fail"); 
     
    330333                goto abort_multicast_ipv6; 
    331334        } 
    332         if (!udp_fd_isset(s1)) { 
     335        if (!udp_fd_isset(&rfd, &max_fd, s1)) { 
    333336                printf("fail: no data on file descriptor\n"); 
    334337                goto abort_multicast_ipv6; 
     
    382385                timeout.tv_sec  = 10; 
    383386                timeout.tv_usec = 0; 
    384                 udp_fd_zero(); 
    385                 udp_fd_set(s2); 
    386                 rc = udp_select(&timeout); 
     387                udp_fd_zero( &rfd, &max_fd ); 
     388                udp_fd_set( &rfd, &max_fd, s2 ); 
     389                rc = udp_select(&rfd, max_fd, &timeout); 
    387390                if (rc < 0) { 
    388391                        perror("fail (child)"); 
     
    393396                        exit(0); 
    394397                } 
    395                 if (!udp_fd_isset(s2)) { 
     398                if (!udp_fd_isset(&rfd, &max_fd, s2)) { 
    396399                        printf("fail (child): no data on file descriptor\n"); 
    397400                        exit(0); 
     
    416419                timeout.tv_sec  = 10; 
    417420                timeout.tv_usec = 0; 
    418                 udp_fd_zero(); 
    419                 udp_fd_set(s1); 
    420                 rc = udp_select(&timeout); 
     421                udp_fd_zero( &rfd, &max_fd ); 
     422                udp_fd_set( &rfd, &max_fd, s1 ); 
     423                rc = udp_select(&rfd, max_fd, &timeout); 
    421424                if (rc < 0) { 
    422425                        perror("fail (parent)"); 
     
    427430                        goto abort_bsd; 
    428431                } 
    429                 if (!udp_fd_isset(s1)) { 
     432                if (!udp_fd_isset(&rfd, &max_fd, s1)) { 
    430433                        printf("fail (parent): no data on file descriptor\n"); 
    431434                        goto abort_bsd;