Changeset 69

Show
Ignore:
Timestamp:
02/19/99 00:48:14 (15 years ago)
Author:
ucaccsp
Message:

Minimal support for sending RTCP packets (empty RR followed by CNAME). It
does interwork with rat, at least!
Colin

Files:
1 modified

Legend:

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

    r66 r69  
    547547} 
    548548 
     549static char *get_cname(socket_udp *s) 
     550{ 
     551        /* Set the CNAME. This is "user@hostname" or just "hostname" if the username cannot be found. */ 
     552        char                    *uname; 
     553        char                    *hname; 
     554        char                    *cname; 
     555#ifndef WIN32 
     556        struct passwd           *pwent; 
     557#endif 
     558 
     559        cname = (char *) xmalloc(MAXHOSTNAMELEN + 10); 
     560        cname[0] = '\0'; 
     561 
     562        /* First, fill in the username... */ 
     563#ifdef WIN32 
     564        uname = getenv("USER"); 
     565#else 
     566        pwent = getpwuid(getuid()); 
     567        uname = pwent->pw_name; 
     568#endif 
     569        if (uname != NULL) { 
     570                sprintf(cname, "%s@", uname); 
     571        } 
     572 
     573        /* Now the hostname. Must be dotted-quad IP address. */ 
     574        hname = udp_host_addr(s); 
     575        strcpy(cname + strlen(cname), hname); 
     576        xfree(hname); 
     577        return cname; 
     578} 
     579 
    549580struct rtp *rtp_init(char *addr, u_int16 port, int ttl, double rtcp_bw, void (*callback)(struct rtp *session, rtp_event *e)) 
    550581{ 
    551582        struct rtp      *session; 
    552583        int              i; 
     584        char            *cname; 
    553585 
    554586        assert(ttl >= 0 && ttl < 128); 
     
    580612                session->db[i] = NULL; 
    581613        } 
     614 
     615        /* Create a database entry for ourselves... */ 
    582616        create_source(session, session->my_ssrc); 
     617        cname = get_cname(session->rtp_socket); 
     618        rtp_set_sdes(session, session->my_ssrc, RTCP_SDES_CNAME, cname, strlen(cname)); 
     619        xfree(cname);   /* cname is copied by rtp_set_sdes()... */ 
     620 
    583621        return session; 
    584622} 
     
    11291167} 
    11301168 
    1131 #ifdef NDEF 
    1132 static u_int8 *format_rtcp_sr(u_int8 *buffer, struct rtp *session, u_int32 ts) 
     1169static u_int8 *format_rtcp_sr(u_int8 *buffer, int buflen, struct rtp *session, u_int32 ts) 
    11331170{ 
    11341171        /* Write an RTCP SR header into buffer, returning a pointer */ 
    11351172        /* to the next byte after the header we have just written.  */ 
    1136         return buffer; 
    1137 } 
    1138  
    1139 static u_int8 *format_rtcp_rr(u_int8 *buffer, struct rtp *session, u_int32 ts) 
     1173        u_int8          *packet = buffer; 
     1174        rtcp_common      common; 
     1175        rtcp_sr          sr; 
     1176 
     1177        assert(buflen > (int) (sizeof(rtcp_common) + sizeof(rtcp_sr))); 
     1178 
     1179        common.version = 2; 
     1180        common.p       = 0; 
     1181        common.count   = 0; 
     1182        common.pt      = RTCP_SR; 
     1183        common.length  = 0; 
     1184 
     1185        memcpy(packet, &common, sizeof(common));  
     1186        packet += sizeof(common); 
     1187 
     1188        sr.ssrc          = htonl(rtp_my_ssrc(session)); 
     1189        sr.ntp_sec       = 0; 
     1190        sr.ntp_frac      = 0; 
     1191        sr.rtp_ts        = htonl(ts); 
     1192        sr.sender_pcount = 0; 
     1193        sr.sender_bcount = 0; 
     1194 
     1195        memcpy(packet, &sr, sizeof(sr));  
     1196        packet += sizeof(sr); 
     1197 
     1198        /* ...fill out the RRs... */ 
     1199 
     1200        return packet; 
     1201} 
     1202 
     1203static u_int8 *format_rtcp_rr(u_int8 *buffer, int buflen, struct rtp *session, u_int32 ts) 
    11401204{ 
    11411205        /* Write an RTCP RR header into buffer, returning a pointer */ 
    11421206        /* to the next byte after the header we have just written.  */ 
    1143         return buffer; 
    1144 } 
    1145  
    1146 static u_int8 *format_rtcp_sdes(u_int8 *buffer, struct rtp *session) 
    1147 { 
    1148         return buffer; 
    1149 } 
     1207        /* Write an RTCP SR header into buffer, returning a pointer */ 
     1208        /* to the next byte after the header we have just written.  */ 
     1209        u_int8          *packet = buffer; 
     1210        rtcp_common      common; 
     1211 
     1212        UNUSED(session); 
     1213        UNUSED(ts); 
     1214 
     1215        assert(buflen > (int) (sizeof(rtcp_common) + sizeof(rtcp_rr))); 
     1216 
     1217        common.version = 2; 
     1218        common.p       = 0; 
     1219        common.count   = 0; 
     1220        common.pt      = RTCP_RR; 
     1221        common.length  = htons(1); 
     1222 
     1223        memcpy(packet, &common, sizeof(common));  
     1224        packet += sizeof(common); 
     1225        *((u_int32 *) packet) = htonl(rtp_my_ssrc(session)); 
     1226        packet += 4; 
     1227 
     1228#ifdef NDEF 
     1229        rr.srrc          = htonl(rtp_my_srrc(session)); 
     1230        rr.ntp_sec       = 0; 
     1231        rr.ntp_frac      = 0; 
     1232        rr.rtp_ts        = htonl(ts); 
     1233        rr.sender_pcount = 0; 
     1234        rr.sender_bcount = 0; 
     1235 
     1236        memcpy(packet, &rr, sizeof(rr));  
     1237        packet += sizeof(rr); 
    11501238#endif 
    11511239 
     1240        /* ...fill out the RRs... */ 
     1241 
     1242        return packet; 
     1243} 
     1244 
     1245/* 
     1246 * Fill out an SDES item.  I assume here that the item is a NULL terminated 
     1247 * string. 
     1248 */ 
     1249static int add_sdes_item(u_int8 *buf, int type, char *val) 
     1250{ 
     1251        rtcp_sdes_item *shdr = (rtcp_sdes_item *) buf; 
     1252        int             namelen; 
     1253 
     1254        if (val == NULL) { 
     1255                debug_msg("Cannot format SDES item. type=%d val=%xp\n", type, val); 
     1256                return 0; 
     1257        } 
     1258        shdr->type = type; 
     1259        namelen = strlen(val); 
     1260        shdr->length = namelen; 
     1261        strcpy(shdr->data, val); 
     1262        return namelen + 2; 
     1263} 
     1264 
     1265static u_int8 *format_rtcp_sdes(u_int8 *buffer, int buflen, struct rtp *session) 
     1266{ 
     1267        u_int8          *packet = buffer; 
     1268        rtcp_common     *common = (rtcp_common *) buffer; 
     1269 
     1270        assert(buflen > (int) sizeof(rtcp_common)); 
     1271 
     1272        common->version = 2; 
     1273        common->p       = 0; 
     1274        common->count   = 1; 
     1275        common->pt      = RTCP_SDES; 
     1276        common->length  = 0; 
     1277        packet += sizeof(common); 
     1278 
     1279        /* Add SDES items following the fixed header... */ 
     1280        *((u_int32 *) packet) = htonl(rtp_my_ssrc(session)); 
     1281        packet += 4; 
     1282        packet += add_sdes_item(packet, RTCP_SDES_CNAME, rtp_get_sdes(session, rtp_my_ssrc(session), RTCP_SDES_CNAME)); 
     1283 
     1284        /* Pad to a multiple of 4 bytes... */ 
     1285        while ((((int) (packet - buffer)) % 4) != 0) { 
     1286                *packet++ = '\0'; 
     1287        } 
     1288 
     1289        common->length = htons(((int) (packet - buffer) / 4) - 1); 
     1290 
     1291        return packet; 
     1292} 
     1293 
    11521294static void send_rtcp(struct rtp *session, u_int32 ts) 
    11531295{ 
    1154 #ifdef NDEF 
    11551296        u_int8   buffer[RTP_MAX_PACKET_LEN]; 
    11561297        u_int8  *ptr = buffer; 
    11571298 
    11581299        if (session->we_sent) { 
    1159                 ptr = format_rtcp_sr(ptr, session, ts); 
     1300                ptr = format_rtcp_sr(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), session, ts); 
    11601301        } else { 
    1161                 ptr = format_rtcp_rr(ptr, session, ts); 
    1162         } 
    1163         ptr = format_rtcp_sdes(ptr, session); 
     1302                ptr = format_rtcp_rr(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), session, ts); 
     1303        } 
     1304        ptr = format_rtcp_sdes(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), session); 
    11641305        udp_send(session->rtcp_socket, buffer, ptr - buffer); 
    1165 #else 
    1166         UNUSED(session); 
    1167         UNUSED(ts); 
    1168 #endif 
    11691306} 
    11701307 
     
    11731310        /* Send an RTCP packet, if one is due... */ 
    11741311        struct timeval   curr_time; 
    1175  
    1176         UNUSED(ts); 
    11771312 
    11781313        gettimeofday(&curr_time, NULL);