MGCP updates to try to improve CID delivery
[asterisk/asterisk.git] / channels / chan_mgcp.c
index b81a670..8f4a761 100755 (executable)
@@ -40,6 +40,7 @@
 #include <arpa/inet.h>
 #include <sys/signal.h>
 #include <asterisk/dsp.h>
+#include <ctype.h>
 
 #define MGCPDUMPER
 #define DEFAULT_EXPIREY 120
@@ -71,6 +72,7 @@ static int restart_monitor(void);
 
 /* Just about everybody seems to support ulaw, so make it a nice default */
 static int capability = AST_FORMAT_ULAW;
+static int nonCodecCapability = AST_RTP_DTMF;
 
 static char ourhost[256];
 static struct in_addr __ourip;
@@ -107,6 +109,14 @@ static struct mgcp_pkt {
        struct mgcp_pkt *next;
 } *packets = NULL;     
 
+/* MGCP message for queuing up */
+struct mgcp_message {
+       unsigned int seqno;
+       int len;
+       struct mgcp_message *next;
+       unsigned char buf[0];
+};
+
 #define TYPE_TRUNK             1
 #define TYPE_LINE              2
 
@@ -133,11 +143,14 @@ struct mgcp_endpoint {
        int alreadygone;
        int needdestroy;
        int capability;
+       int nonCodecCapability;
        int outgoing;
        struct ast_dsp *vad;
        struct ast_channel *owner;
        struct ast_rtp *rtp;
        struct sockaddr_in tmpdest;
+       struct mgcp_message *msgs;                      /* Message queue */
+       int messagepending;
        struct mgcp_endpoint *next;
        struct mgcp_gateway *parent;
 };
@@ -191,12 +204,52 @@ static int send_response(struct mgcp_endpoint *p, struct mgcp_request *req)
        return res;
 }
 
-static int send_request(struct mgcp_endpoint *p, struct mgcp_request *req)
+static void dump_queue(struct mgcp_endpoint *p)
+{
+       struct mgcp_message *cur;
+       while(p->msgs) {
+               cur = p->msgs;
+               p->msgs = p->msgs->next;
+               free(cur);
+       }
+       p->messagepending = 0;
+       p->msgs = NULL;
+}
+
+static int mgcp_postrequest(struct mgcp_endpoint *p, unsigned char *data, int len, unsigned int seqno)
+{
+       struct mgcp_message *msg = malloc(sizeof(struct mgcp_message) + len);
+       struct mgcp_message *cur;
+       if (!msg)
+               return -1;
+       msg->seqno = seqno;
+       msg->next = NULL;
+       msg ->len = len;
+       memcpy(msg->buf, data, msg->len);
+       cur = p->msgs;
+       if (cur) {
+               while(cur->next)
+                       cur = cur->next;
+               cur->next = msg;
+       } else
+               p->msgs = msg;
+       if (!p->messagepending) {
+               p->messagepending = 1;
+               p->lastout = seqno;
+               __mgcp_xmit(p, msg->buf, msg->len);
+               /* XXX Should schedule retransmission XXX */
+       } else
+               ast_log(LOG_DEBUG, "Deferring transmission of transaction %d\n", seqno);
+       return 0;
+}
+
+static int send_request(struct mgcp_endpoint *p, struct mgcp_request *req, unsigned int seqno)
 {
        int res;
        if (mgcpdebug)
-               ast_verbose("XXX Need to handle Retransmitting XXX:\n%s to %s:%d\n", req->data, inet_ntoa(p->parent->addr.sin_addr), ntohs(p->parent->addr.sin_port));
-       res = __mgcp_xmit(p, req->data, req->len);
+               ast_verbose("Posting Request:\n%s to %s:%d\n", req->data, inet_ntoa(p->parent->addr.sin_addr), ntohs(p->parent->addr.sin_port));
+               
+       res = mgcp_postrequest(p, req->data, req->len, seqno);
        return res;
 }
 
@@ -214,7 +267,7 @@ static int mgcp_call(struct ast_channel *ast, char *dest, int timeout)
        res = 0;
        p->outgoing = 1;
        if (p->type == TYPE_LINE) {
-               transmit_notify_request_with_callerid(p, "rg", 0, ast->callerid);
+               transmit_notify_request_with_callerid(p, "L/rg", 0, ast->callerid);
                ast_setstate(ast, AST_STATE_RINGING);
                ast_queue_control(ast, AST_CONTROL_RINGING, 0);
        } else {
@@ -568,21 +621,41 @@ static struct ast_channel *mgcp_new(struct mgcp_endpoint *i, int state)
        return tmp;
 }
 
-static char *get_sdp(struct mgcp_request *req, char *name)
-{
-       int x;
-       int len = strlen(name);
-       char *r;
-       for (x=0;x<req->lines;x++) {
-               if (!strncasecmp(req->line[x], name, len) && 
-                               (req->line[x][len] == '=')) {
-                                       r = req->line[x] + len + 1;
-                                       while(*r && (*r < 33))
-                                                       r++;
-                                       return r;
-               }
-       }
-       return "";
+static char* get_sdp_by_line(char* line, char *name, int nameLen) {
+  if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
+    char* r = line + nameLen + 1;
+    while (*r && (*r < 33)) ++r;
+    return r;
+  }
+
+  return "";
+}
+
+static char *get_sdp(struct mgcp_request *req, char *name) {
+  int x;
+  int len = strlen(name);
+  char *r;
+
+  for (x=0; x<req->lines; x++) {
+    r = get_sdp_by_line(req->line[x], name, len);
+    if (r[0] != '\0') return r;
+  }
+  return "";
+}
+
+static void sdpLineNum_iterator_init(int* iterator) {
+  *iterator = 0;
+}
+
+static char* get_sdp_iterate(int* iterator,
+                            struct mgcp_request *req, char *name) {
+  int len = strlen(name);
+  char *r;
+  while (*iterator < req->lines) {
+    r = get_sdp_by_line(req->line[(*iterator)++], name, len);
+    if (r[0] != '\0') return r;
+  }
+  return "";
 }
 
 static char *__get_header(struct mgcp_request *req, char *name, int *start)
@@ -803,14 +876,17 @@ static int process_sdp(struct mgcp_endpoint *p, struct mgcp_request *req)
 {
        char *m;
        char *c;
+       char *a;
        char host[258];
        int len;
        int portno;
-       int peercapability;
+       int peercapability, peerNonCodecCapability;
        struct sockaddr_in sin;
        char *codecs;
        struct hostent *hp;
        int codec;
+       int iterator;
+
        /* Get codec and RTP info from SDP */
        m = get_sdp(req, "m");
        c = get_sdp(req, "c");
@@ -835,30 +911,44 @@ static int process_sdp(struct mgcp_endpoint *p, struct mgcp_request *req)
        sin.sin_family = AF_INET;
        memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
        sin.sin_port = htons(portno);
-       if (p->rtp)
-               ast_rtp_set_peer(p->rtp, &sin);
+       ast_rtp_set_peer(p->rtp, &sin);
 #if 0
        printf("Peer RTP is at port %s:%d\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
 #endif 
-       peercapability = 0;
+       // Scan through the RTP payload types specified in a "m=" line:
+    ast_rtp_pt_clear(p->rtp);
        codecs = m + len;
        while(strlen(codecs)) {
                if (sscanf(codecs, "%d %n", &codec, &len) != 1) {
                        ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
                        return -1;
                }
-#if 0
-               printf("Codec: %d\n", codec);
-#endif         
-               codec = rtp2ast(codec);
-               if (codec  > -1)
-                       peercapability |= codec;
+               ast_rtp_set_m_type(p->rtp, codec);
                codecs += len;
        }
+
+        // Next, scan through each "a=rtpmap:" line, noting each
+        // specified RTP payload type (with corresponding MIME subtype):
+        sdpLineNum_iterator_init(&iterator);
+        while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
+          char* mimeSubtype = strdup(a); // ensures we have enough space
+          if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
+          // Note: should really look at the 'freq' and '#chans' params too
+          ast_rtp_set_rtpmap_type(p->rtp, codec, "audio", mimeSubtype);
+         free(mimeSubtype);
+        }
+
+        // Now gather all of the codecs that were asked for:
+        ast_rtp_get_current_formats(p->rtp,
+                                &peercapability, &peerNonCodecCapability);
        p->capability = capability & peercapability;
-       if (mgcpdebug)
+       if (mgcpdebug) {
                ast_verbose("Capabilities: us - %d, them - %d, combined - %d\n",
                capability, peercapability, p->capability);
+               ast_verbose("Non-codec capabilities: us - %d, them - %d, combined - %d\n",
+                            nonCodecCapability, peerNonCodecCapability,
+                            p->nonCodecCapability);
+       }
        if (!p->capability) {
                ast_log(LOG_WARNING, "No compatible codecs!\n");
                return -1;
@@ -1014,18 +1104,38 @@ static int add_sdp(struct mgcp_request *resp, struct mgcp_endpoint *p, struct as
        snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", inet_ntoa(dest.sin_addr));
        snprintf(t, sizeof(t), "t=0 0\r\n");
        snprintf(m, sizeof(m), "m=audio %d RTP/AVP", ntohs(dest.sin_port));
-       for (x=1;x<= AST_FORMAT_MAX_AUDIO; x <<= 1) {
+       for (x = 1; x <= AST_FORMAT_MAX_AUDIO; x <<= 1) {
                if (p->capability & x) {
                        if (mgcpdebug)
                                ast_verbose("Answering with capability %d\n", x);
-                       if ((codec = ast2rtp(x)) > -1) {
+                       codec = ast_rtp_lookup_code(p->rtp, 1, x);
+                        if (codec > -1) {
                                snprintf(costr, sizeof(costr), " %d", codec);
                                strcat(m, costr);
-                               snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast2rtpn(x));
+                               snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, x));
                                strcat(a, costr);
                        }
                }
        }
+       for (x = 1; x <= AST_RTP_MAX; x <<= 1) {
+               if (p->nonCodecCapability & x) {
+                       if (mgcpdebug)
+                               ast_verbose("Answering with non-codec capability %d\n", x);
+                       codec = ast_rtp_lookup_code(p->rtp, 0, x);
+                       if (codec > -1) {
+                               snprintf(costr, sizeof(costr), " %d", codec);
+                               strcat(m, costr);
+                               snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(0, x));
+                               strcat(a, costr);
+                               if (x == AST_RTP_DTMF) {
+                                 /* Indicate we support DTMF...  Not sure about 16, but MSN supports it so dang it, we will too... */
+                                 snprintf(costr, sizeof costr, "a=fmtp:%d 0-16\r\n",
+                                          codec);
+                                 strcat(a, costr);
+                               }
+                       }
+               }
+        }
        strcat(m, "\r\n");
        len = strlen(v) + strlen(s) + strlen(o) + strlen(c) + strlen(t) + strlen(m) + strlen(a);
        snprintf(costr, sizeof(costr), "%d", len);
@@ -1054,7 +1164,7 @@ static int transmit_modify_with_sdp(struct mgcp_endpoint *p, struct ast_rtp *rtp
        snprintf(local, sizeof(local), "p:20");
        for (x=1;x<= AST_FORMAT_MAX_AUDIO; x <<= 1) {
                if (p->capability & x) {
-                       snprintf(tmp, sizeof(tmp), ", a:%s", ast2rtpn(x));
+                       snprintf(tmp, sizeof(tmp), ", a:%s", ast_rtp_lookup_mime_subtype(1, x));
                        strcat(local, tmp);
                }
        }
@@ -1066,8 +1176,7 @@ static int transmit_modify_with_sdp(struct mgcp_endpoint *p, struct ast_rtp *rtp
        add_header(&resp, "I", p->cxident);
        add_header(&resp, "S", "");
        add_sdp(&resp, p, rtp);
-       p->lastout = oseq;
-       return send_request(p, &resp);
+       return send_request(p, &resp, oseq);
 }
 
 static int transmit_connect_with_sdp(struct mgcp_endpoint *p, struct ast_rtp *rtp)
@@ -1079,7 +1188,7 @@ static int transmit_connect_with_sdp(struct mgcp_endpoint *p, struct ast_rtp *rt
        snprintf(local, sizeof(local), "p:20");
        for (x=1;x<= AST_FORMAT_MAX_AUDIO; x <<= 1) {
                if (p->capability & x) {
-                       snprintf(tmp, sizeof(tmp), ", a:%s", ast2rtpn(x));
+                       snprintf(tmp, sizeof(tmp), ", a:%s", ast_rtp_lookup_mime_subtype(1, x));
                        strcat(local, tmp);
                }
        }
@@ -1090,8 +1199,7 @@ static int transmit_connect_with_sdp(struct mgcp_endpoint *p, struct ast_rtp *rt
        add_header(&resp, "X", p->txident);
        add_header(&resp, "S", "");
        add_sdp(&resp, p, rtp);
-       p->lastout = oseq;
-       return send_request(p, &resp);
+       return send_request(p, &resp, oseq);
 }
 
 static int transmit_notify_request(struct mgcp_endpoint *p, char *tone, int offhook)
@@ -1105,7 +1213,7 @@ static int transmit_notify_request(struct mgcp_endpoint *p, char *tone, int offh
        else
                add_header(&resp, "R", "hd(N)");
        add_header(&resp, "S", tone);
-       return send_request(p, &resp);
+       return send_request(p, &resp, oseq);
 }
 
 static int transmit_notify_request_with_callerid(struct mgcp_endpoint *p, char *tone, int offhook, char *callerid)
@@ -1135,17 +1243,17 @@ static int transmit_notify_request_with_callerid(struct mgcp_endpoint *p, char *
                n = "O";
        if (!l)
                l = "";
-       snprintf(tone2, sizeof(tone2), "%s, ci(%02d/%02d/%02d/%02d,%s,%s)", tone, 
+       snprintf(tone2, sizeof(tone2), "%s,L/ci(%02d/%02d/%02d/%02d,%s,%s)", tone, 
                        tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, l, n);
        strncpy(p->curtone, tone, sizeof(p->curtone) - 1);
        reqprep(&resp, p, "RQNT");
        add_header(&resp, "X", p->txident);
        if (offhook)
-               add_header(&resp, "R", "hu(N), hf(N), D/[0-9#*](N)");
+               add_header(&resp, "R", "hu(N),hf(N),D/[0-9#*](N)");
        else
                add_header(&resp, "R", "hd(N)");
        add_header(&resp, "S", tone2);
-       return send_request(p, &resp);
+       return send_request(p, &resp, oseq);
 }
 static int transmit_connection_del(struct mgcp_endpoint *p)
 {
@@ -1153,11 +1261,28 @@ static int transmit_connection_del(struct mgcp_endpoint *p)
        reqprep(&resp, p, "DLCX");
        add_header(&resp, "C", p->callid);
        add_header(&resp, "I", p->cxident);
-       return send_request(p, &resp);
+       return send_request(p, &resp, oseq);
 }
 
 static void handle_response(struct mgcp_endpoint *p, int result, int ident)
 {
+       struct mgcp_message *cur;
+       if (p->msgs && (p->msgs->seqno == ident)) {
+               ast_log(LOG_DEBUG, "Got response back on tansaction %d\n", ident);
+               cur = p->msgs;
+               p->msgs = p->msgs->next;
+               free(cur);
+               if (p->msgs) {
+                       /* Send next pending message if appropriate */
+                       p->messagepending = 1;
+                       p->lastout = p->msgs->seqno;
+                       __mgcp_xmit(p, p->msgs->buf, p->msgs->len);
+                       /* XXX Should schedule retransmission XXX */
+               } else
+                       p->messagepending = 0;
+       } else {
+               ast_log(LOG_NOTICE, "Got response back on transaction %d we aren't sending? (current = %d)\n", ident, p->msgs ? p->msgs->seqno : -1);
+       }
        if ((result >= 400) && (result <= 499)) {
                ast_log(LOG_NOTICE, "Terminating on result %d from %s@%s\n", result, p->name, p->parent->name);
                if (p->owner)
@@ -1238,11 +1363,13 @@ static int handle_request(struct mgcp_endpoint *p, struct mgcp_request *req, str
                ast_verbose("Handling request '%s' on %s@%s\n", req->verb, p->name, p->parent->name);
        /* Clear out potential response */
        if (!strcasecmp(req->verb, "RSIP")) {
+               dump_queue(p);
                if (option_verbose > 2)
                        ast_verbose(VERBOSE_PREFIX_3 "Resetting interface %s@%s\n", p->name, p->parent->name);
                if (p->owner)
                        ast_softhangup(p->owner, AST_SOFTHANGUP_DEV);
                transmit_response(p, "200", req, "OK");
+               transmit_notify_request(p, "", 0);
        } else if (!strcasecmp(req->verb, "NTFY")) {
                /* Acknowledge and be sure we keep looking for the same things */
                transmit_response(p, "200", req, "OK");
@@ -1284,6 +1411,7 @@ static int handle_request(struct mgcp_endpoint *p, struct mgcp_request *req, str
                                p->alreadygone = 1;
                                ast_queue_hangup(p->owner, 1);
                        }
+                       transmit_notify_request(p, "", 0);
                } else if ((strlen(ev) == 1) && 
                                        (((ev[0] >= '0') && (ev[0] <= '9')) ||
                                         ((ev[0] >= 'A') && (ev[0] <= 'D')) ||
@@ -1351,8 +1479,12 @@ static int mgcpsock_read(int *id, int fd, short events, void *ignore)
                                        }
                                }
                        }
-                       if (req.lines)
-                               process_sdp(p, &req);
+                       if (req.lines) {
+                               if (!p->rtp) 
+                                       start_rtp(p);
+                               if (p->rtp)
+                                       process_sdp(p, &req);
+                       }
                }
        } else {
                if (!req.endpoint || !strlen(req.endpoint) || 
@@ -1765,8 +1897,8 @@ int load_module()
 
 int unload_module()
 {
-       struct mgcp_endpoint *p, *pl;
 #if 0
+       struct mgcp_endpoint *p, *pl;
        /* First, take us out of the channel loop */
        ast_channel_unregister(type);
        if (!ast_pthread_mutex_lock(&gatelock)) {