374459251103e0343a1028afeaca132f8622cc90
[asterisk/asterisk.git] / channels / chan_mgcp.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Implementation of Media Gateway Control Protocol
5  * 
6  * Copyright (C) 1999-2004, Digium, Inc.
7  *
8  * Mark Spencer <markster@digium.com>
9  *
10  * This program is free software, distributed under the terms of
11  * the GNU General Public License
12  */
13
14 /* JS: Changes
15    -- add support for the wildcard endpoint
16    -- seteable wildcard with wcardep on mgcp.conf
17    -- added package indicator on RQNT, i.e "dl" --> "L/dl"
18    -- removed MDCX just before DLCX, do we need this ?
19 */
20
21 /* JS: TODO
22    -- reload for wildcard endpoint probably buggy
23    -- when hf is notified we're sending CRCX after MDCX, without waiting for
24       OK on the MDCX which fails on Cisco IAD 24XX
25    -- honour codec order, by now the lowest codec number in "allow" is the prefered
26 */
27
28 /* SC: Changes
29    -- packet retransmit mechanism (simplistic)
30    -- per endpoint/subchannel mgcp command sequencing. 
31    -- better transaction handling
32    -- fixed some mem leaks
33    -- run-time configuration reload 
34    -- distinguish CA and GW default MGCP ports
35    -- prevent clipping of DTMF tones in an established call
36    -- fixed a few crash scenarios in 3-way
37    -- fix for a few cases where asterisk and MGW end-up in conflicting ep states 
38    -- enclose numeric IP in [] for outgoing requests
39 */
40
41 /* SC: TODO
42    -- piggyback support
43    -- responseAck support
44    -- enhance retransmit mechanism (RTO calc. etc.)
45    -- embedded command support
46 */
47 /* FS: Changes
48  * -- fixed reload_config() / do_monitor to stay responsive during reloads
49  */
50
51 #include <stdio.h>
52 #include <string.h>
53 #include <asterisk/lock.h>
54 #include <asterisk/channel.h>
55 #include <asterisk/channel_pvt.h>
56 #include <asterisk/config.h>
57 #include <asterisk/logger.h>
58 #include <asterisk/module.h>
59 #include <asterisk/pbx.h>
60 #include <asterisk/options.h>
61 #include <asterisk/lock.h>
62 #include <asterisk/sched.h>
63 #include <asterisk/io.h>
64 #include <asterisk/rtp.h>
65 #include <asterisk/acl.h>
66 #include <asterisk/callerid.h>
67 #include <asterisk/cli.h>
68 #include <asterisk/say.h>
69 #include <asterisk/cdr.h>
70 #include <asterisk/astdb.h>
71 #include <asterisk/features.h>
72 #include <asterisk/app.h>
73 #include <asterisk/musiconhold.h>
74 #include <asterisk/utils.h>
75 #include <asterisk/causes.h>
76 #include <sys/socket.h>
77 #include <sys/ioctl.h>
78 #include <net/if.h>
79 #include <errno.h>
80 #include <unistd.h>
81 #include <stdlib.h>
82 #include <fcntl.h>
83 #include <netdb.h>
84 #include <arpa/inet.h>
85 #include <sys/signal.h>
86 #include <signal.h>
87 #include <netinet/in_systm.h>
88 #include <netinet/ip.h>
89
90 #include <asterisk/dsp.h>
91 #include <ctype.h>
92
93 #ifndef IPTOS_MINCOST
94 #define IPTOS_MINCOST 0x02
95 #endif
96
97 /*
98  * Define to work around buggy dlink MGCP phone firmware which
99  * appears not to know that "rt" is part of the "G" package.
100  */
101 /* #define DLINK_BUGGY_FIRMWARE  */
102
103 #define MGCPDUMPER
104 #define DEFAULT_EXPIREY 120
105 #define MAX_EXPIREY     3600
106 #define CANREINVITE     1
107
108 #ifndef INADDR_NONE
109 #define INADDR_NONE (in_addr_t)(-1)
110 #endif
111
112 static char *desc = "Media Gateway Control Protocol (MGCP)";
113 static char *type = "MGCP";
114 static char *tdesc = "Media Gateway Control Protocol (MGCP)";
115 static char *config = "mgcp.conf";
116
117 #define MGCP_DTMF_RFC2833       (1 << 0)
118 #define MGCP_DTMF_INBAND                (1 << 1)
119
120 #define DEFAULT_MGCP_GW_PORT    2427/* From RFC 2705 */
121 #define DEFAULT_MGCP_CA_PORT    2727/* From RFC 2705 */
122 #define MGCP_MAX_PACKET 1500            /* Also from RFC 2543, should sub headers tho */
123 #define DEFAULT_RETRANS         1000   /* How frequently to retransmit */
124 #define MAX_RETRANS             5   /* Try only 5 times for retransmissions */
125
126 /* MGCP rtp stream modes */
127 #define MGCP_CX_SENDONLY 0
128 #define MGCP_CX_RECVONLY 1
129 #define MGCP_CX_SENDRECV 2
130 #define MGCP_CX_CONF     3
131 #define MGCP_CX_CONFERENCE 3
132 #define MGCP_CX_MUTE     4
133 #define MGCP_CX_INACTIVE 4
134
135 static char *mgcp_cxmodes[] = {
136     "sendonly",
137     "recvonly",
138     "sendrecv",
139     "confrnce",
140     "inactive"
141 };
142
143 /* SC: MGCP commands */
144 #define MGCP_CMD_EPCF 0
145 #define MGCP_CMD_CRCX 1
146 #define MGCP_CMD_MDCX 2
147 #define MGCP_CMD_DLCX 3
148 #define MGCP_CMD_RQNT 4
149 #define MGCP_CMD_NTFY 5
150 #define MGCP_CMD_AUEP 6
151 #define MGCP_CMD_AUCX 7
152 #define MGCP_CMD_RSIP 8
153
154 static char context[AST_MAX_EXTENSION] = "default";
155
156 static char language[MAX_LANGUAGE] = "";
157 static char musicclass[MAX_LANGUAGE] = "";
158 static char cid_num[AST_MAX_EXTENSION] = "";
159 static char cid_name[AST_MAX_EXTENSION] = "";
160
161 static int dtmfmode = 0;
162 static int nat = 0;
163
164 /* Not used. Dosn't hurt for us to always send cid  */
165 /* to the mgcp box. */
166 /* static int use_callerid = 1;*/
167 /*static int cur_signalling = -1;*/
168
169 /*static unsigned int cur_group = 0;*/
170 static unsigned int cur_callergroup = 0;
171 static unsigned int cur_pickupgroup = 0;
172
173 /* XXX Is this needed? */
174 /*     Doesn't look like the dsp stuff for */
175 /*     dtmfmode is actually hooked up.   */
176 /* static int relaxdtmf = 0; */
177
178 static int tos = 0;
179
180 static int immediate = 0;
181
182 static int callwaiting = 0;
183
184 /* Not used. Dosn't hurt for us to always send cid  */
185 /* to the mgcp box. */
186 /*static int callwaitingcallerid = 0;*/
187
188 /*static int hidecallerid = 0;*/
189
190 static int callreturn = 0;
191
192 static int slowsequence = 0;
193
194 static int threewaycalling = 0;
195
196 /* This is for flashhook transfers */
197 static int transfer = 0;
198
199 static int cancallforward = 0;
200
201 static int singlepath = 0;
202
203 static int canreinvite = CANREINVITE;
204
205 /*static int busycount = 3;*/
206
207 /*static int callprogress = 0;*/
208
209 static char accountcode[20] = "";
210
211 static char mailbox[AST_MAX_EXTENSION];
212
213 static int amaflags = 0;
214
215 static int adsi = 0;
216
217
218 static int usecnt =0;
219 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
220 /* SC: transaction id should always be positive */
221 static unsigned int oseq;
222
223 /* Wait up to 16 seconds for first digit (FXO logic) */
224 static int firstdigittimeout = 16000;
225
226 /* How long to wait for following digits (FXO logic) */
227 static int gendigittimeout = 8000;
228
229 /* How long to wait for an extra digit, if there is an ambiguous match */
230 static int matchdigittimeout = 3000;
231
232 /* Protect the monitoring thread, so only one process can kill or start it, and not
233    when it's doing something critical. */
234 AST_MUTEX_DEFINE_STATIC(netlock);
235
236 AST_MUTEX_DEFINE_STATIC(monlock);
237
238 /* This is the thread for the monitor which checks for input on the channels
239    which are not currently in use.  */
240 static pthread_t monitor_thread = AST_PTHREADT_NULL;
241
242 static int restart_monitor(void);
243
244 /* Just about everybody seems to support ulaw, so make it a nice default */
245 static int capability = AST_FORMAT_ULAW;
246 static int nonCodecCapability = AST_RTP_DTMF;
247
248 static char ourhost[256];
249 static struct in_addr __ourip;
250 static int ourport;
251
252 static int mgcpdebug = 0;
253
254 static struct sched_context *sched;
255 static struct io_context *io;
256 /* The private structures of the  mgcp channels are linked for
257    selecting outgoing channels */
258    
259 #define MGCP_MAX_HEADERS                64
260 #define MGCP_MAX_LINES          64
261
262 struct mgcp_request {
263         int len;
264         char *verb;
265         char *identifier;
266         char *endpoint;
267         char *version;
268         int headers;                                    /* MGCP Headers */
269         char *header[MGCP_MAX_HEADERS];
270         int lines;                                              /* SDP Content */
271         char *line[MGCP_MAX_LINES];
272         char data[MGCP_MAX_PACKET];
273     int cmd;                        /* SC: int version of verb = command */
274     unsigned int trid;              /* SC: int version of identifier = transaction id */
275     struct mgcp_request *next;      /* SC: next in the queue */
276 };
277
278 /* SC: obsolete
279 static struct mgcp_pkt {
280         int retrans;
281         struct mgcp_endpoint *owner;
282         int packetlen;
283         char data[MGCP_MAX_PACKET];
284         struct mgcp_pkt *next;
285 } *packets = NULL;      
286 */
287
288 /* MGCP message for queuing up */
289 struct mgcp_message {
290     struct mgcp_endpoint *owner_ep;
291     struct mgcp_subchannel *owner_sub;
292     int retrans;
293     unsigned long expire;
294         unsigned int seqno;
295         int len;
296         struct mgcp_message *next;
297         unsigned char buf[0];
298 };
299
300 #define RESPONSE_TIMEOUT 30     /* in seconds */
301
302 struct mgcp_response {
303         time_t whensent;
304         int len;
305         int seqno;
306         struct mgcp_response *next;
307         unsigned char buf[0];
308 };
309
310 #define MAX_SUBS 2
311
312 #define SUB_REAL 0
313 #define SUB_ALT  1
314
315 struct mgcp_subchannel {
316     /* SC: subchannel magic string. 
317        Needed to prove that any subchannel pointer passed by asterisk 
318        really points to a valid subchannel memory area.
319        Ugly.. But serves the purpose for the time being.
320      */
321 #define MGCP_SUBCHANNEL_MAGIC "!978!"
322     char magic[6]; 
323         ast_mutex_t lock;
324     int id;
325     struct ast_channel *owner;
326     struct mgcp_endpoint *parent;
327     struct ast_rtp *rtp;
328         struct sockaddr_in tmpdest;
329         char txident[80];              /* FIXME SC: txident is replaced by rqnt_ident in endpoint. 
330                                       This should be obsoleted */
331     char cxident[80];
332     char callid[80];
333 /* SC: obsolete
334     time_t lastouttime;
335     int lastout;
336 */
337     int cxmode;
338     struct mgcp_request *cx_queue; /* SC: pending CX commands */
339         ast_mutex_t cx_queue_lock;     /* SC: CX queue lock */
340         int nat;
341         int iseq; /* Not used? RTP? */
342         int outgoing;
343         int alreadygone;
344 /* SC: obsolete
345         int messagepending;
346         struct mgcp_message *msgs;
347 */
348     struct mgcp_subchannel *next; /* for out circular linked list */
349 };
350
351 #define MGCP_ONHOOK 1
352 #define MGCP_OFFHOOK 2
353
354 #define TYPE_TRUNK              1
355 #define TYPE_LINE               2
356
357 struct mgcp_endpoint {
358         ast_mutex_t lock;
359         char name[80];
360     struct mgcp_subchannel *sub;        /* pointer to our current connection, channel and stuff */
361         char accountcode[80];
362         char exten[AST_MAX_EXTENSION];          /* Extention where to start */
363         char context[AST_MAX_EXTENSION];
364         char language[MAX_LANGUAGE];
365         char cid_num[AST_MAX_EXTENSION];        /* Caller*ID */
366         char cid_name[AST_MAX_EXTENSION];       /* Caller*ID */
367         char lastcallerid[AST_MAX_EXTENSION];   /* Last Caller*ID */
368         char call_forward[AST_MAX_EXTENSION];   /* Last Caller*ID */
369     char mailbox[AST_MAX_EXTENSION];
370     char musicclass[MAX_LANGUAGE];
371         char curtone[80];                                       /* Current tone */
372     unsigned int callgroup;
373     unsigned int pickupgroup;
374         int callwaiting;
375     int transfer;
376     int threewaycalling;
377         int singlepath;
378         int cancallforward;
379         int canreinvite;
380         int callreturn;
381         int dnd; /* How does this affect callwait?  Do we just deny a mgcp_request if we're dnd? */
382         int hascallerid;
383         int hidecallerid;
384         int dtmfmode;
385         int amaflags;
386         int type;
387         int slowsequence;                                 /* MS: Sequence the endpoint as a whole */
388         int group;
389         int iseq; /* Not used? */
390         int lastout; /* tracking this on the subchannels.  Is it needed here? */
391         int needdestroy; /* Not used? */
392         int capability;
393         int nonCodecCapability;
394     int onhooktime;
395     int msgstate; /* voicemail message state */
396     int immediate;
397     int hookstate;
398     int adsi;
399         char rqnt_ident[80];             /* SC: request identifier */
400     struct mgcp_request *rqnt_queue; /* SC: pending RQNT commands */
401         ast_mutex_t rqnt_queue_lock;
402     struct mgcp_request *cmd_queue;  /* SC: pending commands other than RQNT */
403         ast_mutex_t cmd_queue_lock;
404     int delme;                       /* SC: needed for reload */
405     int needaudit;                   /* SC: needed for reload */
406         struct ast_dsp *dsp; /* XXX Should there be a dsp/subchannel? XXX */
407     /* owner is tracked on the subchannels, and the *sub indicates whos in charge */
408         /* struct ast_channel *owner; */
409         /* struct ast_rtp *rtp; */
410         /* struct sockaddr_in tmpdest; */
411     /* message go the the endpoint and not the channel so they stay here */
412         struct mgcp_endpoint *next;
413         struct mgcp_gateway *parent;
414 };
415
416 static struct mgcp_gateway {
417         /* A gateway containing one or more endpoints */
418         char name[80];
419     int isnamedottedip; /* SC: is the name FQDN or dotted ip */
420         struct sockaddr_in addr;
421         struct sockaddr_in defaddr;
422         struct in_addr ourip;
423         int dynamic;
424         int expire;             /* XXX Should we ever expire dynamic registrations? XXX */
425         struct mgcp_endpoint *endpoints;
426         struct ast_ha *ha;
427 /* SC: obsolete
428     time_t lastouttime;
429     int lastout;
430         int messagepending;
431 */
432 /* JS: Wildcard endpoint name */
433         char wcardep[30];
434         struct mgcp_message *msgs; /* SC: gw msg queue */
435         ast_mutex_t msgs_lock;     /* SC: queue lock */  
436     int retransid;             /* SC: retrans timer id */
437     int delme;                 /* SC: needed for reload */
438         struct mgcp_response *responses;
439         struct mgcp_gateway *next;
440 } *gateways;
441
442 AST_MUTEX_DEFINE_STATIC(mgcp_reload_lock);
443 static int mgcp_reloading = 0;
444
445 AST_MUTEX_DEFINE_STATIC(gatelock);
446
447 static int mgcpsock  = -1;
448
449 static struct sockaddr_in bindaddr;
450
451 static struct ast_frame  *mgcp_read(struct ast_channel *ast);
452 static int transmit_response(struct mgcp_subchannel *sub, char *msg, struct mgcp_request *req, char *msgrest);
453 static int transmit_notify_request(struct mgcp_subchannel *sub, char *tone);
454 static int transmit_modify_request(struct mgcp_subchannel *sub);
455 static int transmit_notify_request_with_callerid(struct mgcp_subchannel *sub, char *tone, char *callernum, char *callername);
456 static int transmit_modify_with_sdp(struct mgcp_subchannel *sub, struct ast_rtp *rtp, int codecs);
457 static int transmit_connection_del(struct mgcp_subchannel *sub);
458 static int transmit_audit_endpoint(struct mgcp_endpoint *p);
459 static void start_rtp(struct mgcp_subchannel *sub);
460 static void handle_response(struct mgcp_endpoint *p, struct mgcp_subchannel *sub,  
461                             int result, unsigned int ident, struct mgcp_request *resp);
462 static void dump_cmd_queues(struct mgcp_endpoint *p, struct mgcp_subchannel *sub);
463 static int mgcp_do_reload(void);
464 static int mgcp_reload(int fd, int argc, char *argv[]);
465
466 static int has_voicemail(struct mgcp_endpoint *p)
467 {
468         return ast_app_has_voicemail(p->mailbox, NULL);
469 }
470
471 static int unalloc_sub(struct mgcp_subchannel *sub)
472 {
473     struct mgcp_endpoint *p = sub->parent;
474         if (p->sub == sub) {
475                 ast_log(LOG_WARNING, "Trying to unalloc the real channel %s@%s?!?\n", p->name, p->parent->name);
476                 return -1;
477         }
478         ast_log(LOG_DEBUG, "Released sub %d of channel %s@%s\n", sub->id, p->name, p->parent->name);
479
480         sub->owner = NULL;
481         if (strlen(sub->cxident)) {
482                 transmit_connection_del(sub);
483     }
484     sub->cxident[0] = '\0';
485     sub->callid[0] = '\0';
486     sub->cxmode = MGCP_CX_INACTIVE;
487         sub->outgoing = 0;
488         sub->alreadygone = 0;
489         memset(&sub->tmpdest, 0, sizeof(sub->tmpdest));
490         if (sub->rtp) {
491                 ast_rtp_destroy(sub->rtp);
492                 sub->rtp = NULL;
493         }
494     dump_cmd_queues(NULL, sub); /* SC */
495         return 0;
496 }
497
498 /* SC: modified for new transport mechanism */
499 static int __mgcp_xmit(struct mgcp_gateway *gw, char *data, int len)
500 {
501         int res;
502         if (gw->addr.sin_addr.s_addr)
503             res=sendto(mgcpsock, data, len, 0, (struct sockaddr *)&gw->addr, sizeof(struct sockaddr_in));
504         else 
505             res=sendto(mgcpsock, data, len, 0, (struct sockaddr *)&gw->defaddr, sizeof(struct sockaddr_in));
506         if (res != len) {
507                 ast_log(LOG_WARNING, "mgcp_xmit returned %d: %s\n", res, strerror(errno));
508         }
509         return res;
510 }
511
512 static int resend_response(struct mgcp_subchannel *sub, struct mgcp_response *resp)
513 {
514     struct mgcp_endpoint *p = sub->parent;
515         int res;
516         char iabuf[INET_ADDRSTRLEN];
517         if (mgcpdebug) {
518                 ast_verbose("Retransmitting:\n%s\n to %s:%d\n", resp->buf, ast_inet_ntoa(iabuf, sizeof(iabuf), p->parent->addr.sin_addr), ntohs(p->parent->addr.sin_port));
519     }
520         res = __mgcp_xmit(p->parent, resp->buf, resp->len);
521         if (res > 0)
522                 res = 0;
523         return res;
524 }
525
526 static int send_response(struct mgcp_subchannel *sub, struct mgcp_request *req)
527 {
528     struct mgcp_endpoint *p = sub->parent;
529         int res;
530         char iabuf[INET_ADDRSTRLEN];
531         if (mgcpdebug) {
532                 ast_verbose("Transmitting:\n%s\n to %s:%d\n", req->data, ast_inet_ntoa(iabuf, sizeof(iabuf), p->parent->addr.sin_addr), ntohs(p->parent->addr.sin_port));
533     }
534         res = __mgcp_xmit(p->parent, req->data, req->len);
535         if (res > 0)
536                 res = 0;
537         return res;
538 }
539
540 /* SC: modified for new transport framework */
541 static void dump_queue(struct mgcp_gateway *gw, struct mgcp_endpoint *p)
542 {
543         struct mgcp_message *cur, *q = NULL, *w, *prev;
544
545     ast_mutex_lock(&gw->msgs_lock);
546     prev = NULL, cur = gw->msgs;
547     while (cur) {
548         if (!p || cur->owner_ep == p) {
549             if (prev)
550                 prev->next = cur->next;
551             else
552                 gw->msgs = cur->next;
553
554             ast_log(LOG_NOTICE, "Removing message from %s transaction %u\n", 
555                     gw->name, cur->seqno);
556
557             w = cur;
558             cur = cur->next;
559             if (q) {
560                 w->next = q;
561             }
562             else {
563                 w->next = NULL;
564             }
565             q = w;
566         }
567         else {
568             prev = cur, cur=cur->next;
569         }
570     }
571     ast_mutex_unlock(&gw->msgs_lock);
572
573     while (q) {
574         cur = q;
575         q = q->next;
576         free(cur);
577     }
578 }
579
580 static void mgcp_queue_frame(struct mgcp_subchannel *sub, struct ast_frame *f)
581 {
582         for(;;) {
583                 if (sub->owner) {
584                         if (!ast_mutex_trylock(&sub->owner->lock)) {
585                                 ast_queue_frame(sub->owner, f);
586                                 ast_mutex_unlock(&sub->owner->lock);
587                                 break;
588                         } else {
589                                 ast_mutex_unlock(&sub->lock);
590                                 usleep(1);
591                                 ast_mutex_lock(&sub->lock);
592                         }
593                 } else
594                         break;
595         }
596 }
597
598 static void mgcp_queue_hangup(struct mgcp_subchannel *sub)
599 {
600         for(;;) {
601                 if (sub->owner) {
602                         if (!ast_mutex_trylock(&sub->owner->lock)) {
603                                 ast_queue_hangup(sub->owner);
604                                 ast_mutex_unlock(&sub->owner->lock);
605                                 break;
606                         } else {
607                                 ast_mutex_unlock(&sub->lock);
608                                 usleep(1);
609                                 ast_mutex_lock(&sub->lock);
610                         }
611                 } else
612                         break;
613         }
614 }
615
616 static void mgcp_queue_control(struct mgcp_subchannel *sub, int control)
617 {
618         struct ast_frame f = { AST_FRAME_CONTROL, };
619         f.subclass = control;
620         return mgcp_queue_frame(sub, &f);
621 }
622
623 static int retrans_pkt(void *data)
624 {
625     struct mgcp_gateway *gw = (struct mgcp_gateway *)data;
626         struct mgcp_message *cur, *exq = NULL, *w, *prev;
627         struct timeval tv;
628     unsigned long t;
629     int res = 0;
630
631         if (gettimeofday(&tv, NULL) < 0) {
632                 /* This shouldn't ever happen, but let's be sure */
633                 ast_log(LOG_NOTICE, "gettimeofday() failed!\n");
634         return 0;
635         }
636
637     t = tv.tv_sec * 1000 + tv.tv_usec / 1000;
638
639     /* find out expired msgs */
640     ast_mutex_lock(&gw->msgs_lock);
641
642     prev = NULL, cur = gw->msgs;
643     while (cur) {
644         if (cur->retrans < MAX_RETRANS) {
645             cur->retrans++;
646             if (mgcpdebug) {
647                 ast_verbose("Retransmitting #%d transaction %u on [%s]\n", cur->retrans, cur->seqno, gw->name);
648             }
649             __mgcp_xmit(gw, cur->buf, cur->len);
650
651             prev = cur;
652             cur = cur->next;
653         }
654         else {
655             if (prev)
656                 prev->next = cur->next;
657             else
658                 gw->msgs = cur->next;
659
660             ast_log(LOG_WARNING, "Maximum retries exceeded for transaction %u on [%s]\n", cur->seqno, gw->name);
661
662             w = cur;
663             cur = cur->next;
664
665             if (exq) {
666                 w->next = exq;
667             }
668             else {
669                 w->next = NULL;
670             }
671             exq = w;
672         }
673     }
674
675     if (!gw->msgs) {
676         gw->retransid = -1;
677         res = 0;
678     }
679     else {
680         res = 1;
681     }
682     ast_mutex_unlock(&gw->msgs_lock);
683
684     while (exq) {
685         cur = exq;
686         /* time-out transaction */
687         handle_response(cur->owner_ep, cur->owner_sub, 406, cur->seqno, NULL); 
688         exq = exq->next;
689         free(cur);
690     }
691
692     return res;
693 }
694
695 /* SC: modified for the new transaction mechanism */
696 static int mgcp_postrequest(struct mgcp_endpoint *p, struct mgcp_subchannel *sub, 
697                             unsigned char *data, int len, unsigned int seqno)
698 {
699         struct mgcp_message *msg = malloc(sizeof(struct mgcp_message) + len);
700         struct mgcp_message *cur;
701         struct mgcp_gateway *gw = ((p && p->parent) ? p->parent : NULL);
702         struct timeval tv;
703
704         if (!msg) {
705                 return -1;
706     }
707     if (!gw) {
708         return -1;
709     }
710 /* SC
711     time(&t);
712     if (gw->messagepending && (gw->lastouttime + 20 < t)) {
713         ast_log(LOG_NOTICE, "Timeout waiting for response to message:%d,  lastouttime: %ld, now: %ld.  Dumping pending queue\n",
714                 gw->msgs ? gw->msgs->seqno : -1, (long) gw->lastouttime, (long) t);
715         dump_queue(sub->parent);
716     }
717 */
718         msg->owner_sub = sub;
719         msg->owner_ep = p;
720         msg->seqno = seqno;
721         msg->next = NULL;
722         msg->len = len;
723         msg->retrans = 0;
724         memcpy(msg->buf, data, msg->len);
725
726     ast_mutex_lock(&gw->msgs_lock);
727         cur = gw->msgs;
728         if (cur) {
729                 while(cur->next)
730                         cur = cur->next;
731                 cur->next = msg;
732         } else {
733                 gw->msgs = msg;
734     }
735
736         if (gettimeofday(&tv, NULL) < 0) {
737                 /* This shouldn't ever happen, but let's be sure */
738                 ast_log(LOG_NOTICE, "gettimeofday() failed!\n");
739         }
740     else {
741         msg->expire = tv.tv_sec * 1000 + tv.tv_usec / 1000 + DEFAULT_RETRANS;
742
743         if (gw->retransid == -1)
744             gw->retransid = ast_sched_add(sched, DEFAULT_RETRANS, retrans_pkt, (void *)gw);
745     }
746     ast_mutex_unlock(&gw->msgs_lock);
747 /* SC
748         if (!gw->messagepending) {
749                 gw->messagepending = 1;
750                 gw->lastout = seqno;
751         gw->lastouttime = t;
752 */
753     __mgcp_xmit(gw, msg->buf, msg->len);
754                 /* XXX Should schedule retransmission XXX */
755 /* SC
756         } else
757                 ast_log(LOG_DEBUG, "Deferring transmission of transaction %d\n", seqno);
758 */
759         return 0;
760 }
761
762 /* SC: modified for new transport */
763 static int send_request(struct mgcp_endpoint *p, struct mgcp_subchannel *sub, 
764                         struct mgcp_request *req, unsigned int seqno)
765 {
766     int res = 0;
767     struct mgcp_request **queue, *q, *r, *t;
768         char iabuf[INET_ADDRSTRLEN];
769     ast_mutex_t *l;
770
771         ast_log(LOG_DEBUG, "Slow sequence is %d\n", p->slowsequence);
772         if (p->slowsequence) {
773                 queue = &p->cmd_queue;
774                 l = &p->cmd_queue_lock;
775                 ast_mutex_lock(l);
776         } else
777     switch (req->cmd) {
778         case MGCP_CMD_DLCX:
779             queue = &sub->cx_queue;
780             l = &sub->cx_queue_lock;
781             ast_mutex_lock(l);
782             q = sub->cx_queue;
783             /* delete pending cx cmds */
784             while (q) {
785                 r = q->next;
786                 free(q);
787                 q = r;
788             }
789             *queue = NULL;
790             break;
791
792         case MGCP_CMD_CRCX:
793         case MGCP_CMD_MDCX:
794             queue = &sub->cx_queue;
795             l = &sub->cx_queue_lock;
796             ast_mutex_lock(l);
797             break;
798
799         case MGCP_CMD_RQNT:
800             queue = &p->rqnt_queue;
801             l = &p->rqnt_queue_lock;
802             ast_mutex_lock(l);
803             break;
804
805         default:
806             queue = &p->cmd_queue;
807             l = &p->cmd_queue_lock;
808             ast_mutex_lock(l);
809             break;
810     }
811
812     r = (struct mgcp_request *) malloc (sizeof(struct mgcp_request));
813     if (!r) {
814         ast_log(LOG_WARNING, "Cannot post MGCP request: insufficient memory\n");
815         ast_mutex_unlock(l);
816         return -1;
817     }
818     memcpy(r, req, sizeof(struct mgcp_request));
819
820     if (!(*queue)) {
821         if (mgcpdebug) {
822             ast_verbose("Posting Request:\n%s to %s:%d\n", req->data, 
823                         ast_inet_ntoa(iabuf, sizeof(iabuf), p->parent->addr.sin_addr), ntohs(p->parent->addr.sin_port));
824         }
825
826         res = mgcp_postrequest(p, sub, req->data, req->len, seqno);
827     }
828     else {
829         if (mgcpdebug) {
830             ast_verbose("Queueing Request:\n%s to %s:%d\n", req->data, 
831                         ast_inet_ntoa(iabuf, sizeof(iabuf), p->parent->addr.sin_addr), ntohs(p->parent->addr.sin_port));
832         }
833     }
834
835     /* XXX SC: find tail. We could also keep tail in the data struct for faster access */
836     for (t = *queue; t && t->next; t = t->next);
837
838     r->next = NULL;
839     if (t)
840         t->next = r;
841     else
842         *queue = r;
843
844     ast_mutex_unlock(l);
845
846     return res;
847 }
848
849 static int mgcp_call(struct ast_channel *ast, char *dest, int timeout)
850 {
851         int res;
852         struct mgcp_endpoint *p;
853     struct mgcp_subchannel *sub;
854     char *tone;
855
856     if (mgcpdebug) {
857         ast_verbose(VERBOSE_PREFIX_3 "MGCP mgcp_call(%s)\n", ast->name);
858     }
859         sub = ast->pvt->pvt;
860     p = sub->parent;
861         ast_mutex_lock(&sub->lock);
862     switch (p->hookstate) {
863         case MGCP_OFFHOOK:
864             tone = "L/wt";
865             break;
866         case MGCP_ONHOOK:
867         default:
868             tone = "L/rg";
869             break;
870     }
871
872         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
873                 ast_log(LOG_WARNING, "mgcp_call called on %s, neither down nor reserved\n", ast->name);
874                 ast_mutex_unlock(&sub->lock);
875                 return -1;
876         }
877
878         res = 0;
879         sub->outgoing = 1;
880     sub->cxmode = MGCP_CX_RECVONLY;
881         if (p->type == TYPE_LINE) {
882         if (!sub->rtp) {
883             start_rtp(sub);
884         } else {
885             transmit_modify_request(sub);
886         }
887
888         if (sub->next->owner && strlen(sub->next->cxident) && strlen(sub->next->callid)) {
889             /* try to prevent a callwait from disturbing the other connection */
890             sub->next->cxmode = MGCP_CX_RECVONLY;
891             transmit_modify_request(sub->next);
892         }
893
894                 transmit_notify_request_with_callerid(sub, tone, ast->cid.cid_num, ast->cid.cid_name);
895                 ast_setstate(ast, AST_STATE_RINGING);
896
897         if (sub->next->owner && strlen(sub->next->cxident) && strlen(sub->next->callid)) {
898             /* Put the connection back in sendrecv */
899             sub->next->cxmode = MGCP_CX_SENDRECV;
900             transmit_modify_request(sub->next);
901         }
902
903         } else {
904                 ast_log(LOG_NOTICE, "Don't know how to dial on trunks yet\n");
905                 res = -1;
906         }
907         ast_mutex_unlock(&sub->lock);
908         ast_queue_control(ast, AST_CONTROL_RINGING);
909         return res;
910 }
911
912 static int mgcp_hangup(struct ast_channel *ast)
913 {
914         struct mgcp_subchannel *sub = ast->pvt->pvt;
915         struct mgcp_endpoint *p = sub->parent;
916
917         if (option_debug)
918                 ast_log(LOG_DEBUG, "mgcp_hangup(%s)\n", ast->name);
919         if (!ast->pvt->pvt) {
920                 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
921                 return 0;
922         }
923     if (strcmp(sub->magic, MGCP_SUBCHANNEL_MAGIC)) {
924                 ast_log(LOG_DEBUG, "Invalid magic. MGCP subchannel freed up already.\n");
925                 return 0;
926     }
927     if (mgcpdebug) {
928         ast_verbose(VERBOSE_PREFIX_3 "MGCP mgcp_hangup(%s) on %s@%s\n", ast->name, p->name, p->parent->name);
929     }
930
931         if ((p->dtmfmode & MGCP_DTMF_INBAND) && (p->dsp != NULL)){
932         /* SC: check whether other channel is active. */
933         if (!sub->next->owner)
934         {
935             if (mgcpdebug) {
936                 ast_verbose(VERBOSE_PREFIX_2 "MGCP free dsp on %s@%s\n", p->name, p->parent->name);
937             }
938             ast_dsp_free(p->dsp);
939             p->dsp = NULL;
940         }
941     }
942         ast_mutex_lock(&sub->lock);
943
944         sub->owner = NULL;
945         if (strlen(sub->cxident)) {
946                 transmit_connection_del(sub);
947     }
948          sub->cxident[0] = '\0';
949     if ((sub == p->sub) && sub->next->owner) {
950         if (p->hookstate == MGCP_OFFHOOK) {
951             if (sub->next->owner && ast_bridged_channel(sub->next->owner)) {
952                 transmit_notify_request_with_callerid(p->sub, "L/wt", ast_bridged_channel(sub->next->owner)->cid.cid_num, ast_bridged_channel(sub->next->owner)->cid.cid_name);
953             }
954         } else {
955             /* set our other connection as the primary and swith over to it */
956             p->sub = sub->next;
957             p->sub->cxmode = MGCP_CX_RECVONLY;
958             transmit_modify_request(p->sub);
959             if (sub->next->owner && ast_bridged_channel(sub->next->owner)) {
960                 transmit_notify_request_with_callerid(p->sub, "L/rg", ast_bridged_channel(sub->next->owner)->cid.cid_num, ast_bridged_channel(sub->next->owner)->cid.cid_name);
961             }
962         }
963
964     } else if ((sub == p->sub->next) && p->hookstate == MGCP_OFFHOOK) {
965         transmit_notify_request(sub, "L/v");
966     } else if (p->hookstate == MGCP_OFFHOOK) {
967         transmit_notify_request(sub, "L/ro");
968     } else {
969         transmit_notify_request(sub, "");
970     }
971
972         ast->pvt->pvt = NULL;
973         sub->alreadygone = 0;
974         sub->outgoing = 0;
975         sub->cxmode = MGCP_CX_INACTIVE;
976         sub->callid[0] = '\0';
977         /* Reset temporary destination */
978         memset(&sub->tmpdest, 0, sizeof(sub->tmpdest));
979         if (sub->rtp) {
980                 ast_rtp_destroy(sub->rtp);
981                 sub->rtp = NULL;
982         }
983
984         /* SC: Decrement use count */
985     ast_mutex_lock(&usecnt_lock);
986         usecnt--;
987         ast_mutex_unlock(&usecnt_lock);
988         ast_update_use_count();
989     /* SC: Decrement use count */
990
991     if ((p->hookstate == MGCP_ONHOOK) && (!sub->next->rtp)) {
992         if (has_voicemail(p)) {
993             if (mgcpdebug) {
994                 ast_verbose(VERBOSE_PREFIX_3 "MGCP mgcp_hangup(%s) on %s@%s set vmwi(+)\n", ast->name, p->name, p->parent->name);
995             }
996             transmit_notify_request(sub, "L/vmwi(+)");
997         } else {
998             if (mgcpdebug) {
999                 ast_verbose(VERBOSE_PREFIX_3 "MGCP mgcp_hangup(%s) on %s@%s set vmwi(-)\n", ast->name, p->name, p->parent->name);
1000             }
1001             transmit_notify_request(sub, "L/vmwi(-)");
1002         }
1003     }
1004         ast_mutex_unlock(&sub->lock);
1005         return 0;
1006 }
1007
1008 static int mgcp_show_endpoints(int fd, int argc, char *argv[])
1009 {
1010         struct mgcp_gateway  *g;
1011         struct mgcp_endpoint *e;
1012         int hasendpoints = 0;
1013         char iabuf[INET_ADDRSTRLEN];
1014         if (argc != 3) 
1015                 return RESULT_SHOWUSAGE;
1016         ast_mutex_lock(&gatelock);
1017         g = gateways;
1018         while(g) {
1019                 e = g->endpoints;
1020                 ast_cli(fd, "Gateway '%s' at %s (%s)\n", g->name, g->addr.sin_addr.s_addr ? ast_inet_ntoa(iabuf, sizeof(iabuf), g->addr.sin_addr) : ast_inet_ntoa(iabuf, sizeof(iabuf), g->defaddr.sin_addr), g->dynamic ? "Dynamic" : "Static");
1021                 while(e) {
1022                         /* JS: Don't show wilcard endpoint */
1023                         if (strcmp(e->name, g->wcardep) !=0)
1024                                 ast_cli(fd, "   -- '%s@%s in '%s' is %s\n", e->name, g->name, e->context, e->sub->owner ? "active" : "idle");
1025                         hasendpoints = 1;
1026                         e = e->next;
1027                 }
1028                 if (!hasendpoints) {
1029                         ast_cli(fd, "   << No Endpoints Defined >>     ");
1030                 }
1031                 g = g->next;
1032         }
1033         ast_mutex_unlock(&gatelock);
1034         return RESULT_SUCCESS;
1035 }
1036
1037 static char show_endpoints_usage[] = 
1038 "Usage: mgcp show endpoints\n"
1039 "       Lists all endpoints known to the MGCP (Media Gateawy Control Protocol) subsystem.\n";
1040
1041 static struct ast_cli_entry  cli_show_endpoints = 
1042         { { "mgcp", "show", "endpoints", NULL }, mgcp_show_endpoints, "Show defined MGCP endpoints", show_endpoints_usage };
1043
1044 static int mgcp_audit_endpoint(int fd, int argc, char *argv[])
1045 {
1046         struct mgcp_gateway  *g;
1047         struct mgcp_endpoint *e;
1048         int found = 0;
1049     char *ename,*gname, *c;
1050         if (!mgcpdebug) {
1051                 return RESULT_SHOWUSAGE;
1052     }
1053         if (argc != 4) 
1054                 return RESULT_SHOWUSAGE;
1055     /* split the name into parts by null */
1056     ename = argv[3];
1057     gname = ename;
1058     while (*gname) {
1059         if (*gname == '@') {
1060             *gname = 0;
1061             gname++;
1062             break;
1063         }
1064         gname++;
1065     }
1066         if (gname[0] == '[')
1067                 gname++;
1068         if ((c = strrchr(gname, ']')))
1069                 *c = '\0';
1070         ast_mutex_lock(&gatelock);
1071         g = gateways;
1072         while(g) {
1073         if (!strcasecmp(g->name, gname)) {
1074             e = g->endpoints;
1075             while(e) {
1076                 if (!strcasecmp(e->name, ename)) {
1077                     found = 1;
1078                     transmit_audit_endpoint(e);
1079                     break;
1080                 }
1081                 e = e->next;
1082             }
1083             if (found) {
1084                 break;
1085             }
1086         }
1087         g = g->next;
1088         }
1089     if (!found) {
1090         ast_cli(fd, "   << Could not find endpoint >>     ");
1091     }
1092         ast_mutex_unlock(&gatelock);
1093         return RESULT_SUCCESS;
1094 }
1095
1096 static char audit_endpoint_usage[] = 
1097 "Usage: mgcp audit endpoint <endpointid>\n"
1098 "       List the capabilities of an endpoint in the MGCP (Media Gateawy Control Protocol) subsystem.\n"
1099 "       mgcp debug MUST be on to see the results of this command.\n";
1100
1101 static struct ast_cli_entry  cli_audit_endpoint = 
1102         { { "mgcp", "audit", "endpoint", NULL }, mgcp_audit_endpoint, "Audit specified MGCP endpoint", audit_endpoint_usage };
1103
1104 static int mgcp_answer(struct ast_channel *ast)
1105 {
1106         int res = 0;
1107         struct mgcp_subchannel *sub = ast->pvt->pvt;
1108         struct mgcp_endpoint *p = sub->parent;
1109         ast_mutex_lock(&sub->lock);
1110     sub->cxmode = MGCP_CX_SENDRECV;
1111     if (!sub->rtp) {
1112         start_rtp(sub);
1113     } else {
1114         transmit_modify_request(sub);
1115     }
1116     /* SC: verbose level check */
1117     if (option_verbose > 2) {
1118         ast_verbose(VERBOSE_PREFIX_3 "MGCP mgcp_answer(%s) on %s@%s-%d\n", ast->name, p->name, p->parent->name, sub->id);
1119     }
1120         if (ast->_state != AST_STATE_UP) {
1121                 ast_setstate(ast, AST_STATE_UP);
1122                 if (option_debug)
1123                         ast_log(LOG_DEBUG, "mgcp_answer(%s)\n", ast->name);
1124                 transmit_notify_request(sub, "");
1125                 transmit_modify_request(sub);
1126         }
1127         ast_mutex_unlock(&sub->lock);
1128         return res;
1129 }
1130
1131 static struct ast_frame *mgcp_rtp_read(struct mgcp_subchannel *sub)
1132 {
1133         /* Retrieve audio/etc from channel.  Assumes sub->lock is already held. */
1134         struct ast_frame *f;
1135         static struct ast_frame null_frame = { AST_FRAME_NULL, };
1136         f = ast_rtp_read(sub->rtp);
1137         /* Don't send RFC2833 if we're not supposed to */
1138         if (f && (f->frametype == AST_FRAME_DTMF) && !(sub->parent->dtmfmode & MGCP_DTMF_RFC2833))
1139                 return &null_frame;
1140         if (sub->owner) {
1141                 /* We already hold the channel lock */
1142                 if (f->frametype == AST_FRAME_VOICE) {
1143                         if (f->subclass != sub->owner->nativeformats) {
1144                                 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
1145                                 sub->owner->nativeformats = f->subclass;
1146                                 ast_set_read_format(sub->owner, sub->owner->readformat);
1147                                 ast_set_write_format(sub->owner, sub->owner->writeformat);
1148                         }
1149             /* Courtesy fearnor aka alex@pilosoft.com */
1150             if ((sub->parent->dtmfmode & MGCP_DTMF_INBAND) && (sub->parent->dsp)) {
1151 #if 0
1152                 ast_log(LOG_NOTICE, "MGCP ast_dsp_process\n");
1153 #endif
1154                 f = ast_dsp_process(sub->owner, sub->parent->dsp, f);
1155             }
1156                 }
1157         }
1158         return f;
1159 }
1160
1161
1162 static struct ast_frame  *mgcp_read(struct ast_channel *ast)
1163 {
1164         struct ast_frame *f;
1165         struct mgcp_subchannel *sub = ast->pvt->pvt;
1166         ast_mutex_lock(&sub->lock);
1167         f = mgcp_rtp_read(sub);
1168         ast_mutex_unlock(&sub->lock);
1169         return f;
1170 }
1171
1172 static int mgcp_write(struct ast_channel *ast, struct ast_frame *frame)
1173 {
1174         struct mgcp_subchannel *sub = ast->pvt->pvt;
1175         int res = 0;
1176         if (frame->frametype != AST_FRAME_VOICE) {
1177                 if (frame->frametype == AST_FRAME_IMAGE)
1178                         return 0;
1179                 else {
1180                         ast_log(LOG_WARNING, "Can't send %d type frames with MGCP write\n", frame->frametype);
1181                         return 0;
1182                 }
1183         } else {
1184                 if (!(frame->subclass & ast->nativeformats)) {
1185                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
1186                                 frame->subclass, ast->nativeformats, ast->readformat, ast->writeformat);
1187                         return -1;
1188                 }
1189         }
1190         if (sub) {
1191                 ast_mutex_lock(&sub->lock);
1192                 if ((sub->parent->sub == sub) || !sub->parent->singlepath) {
1193                         if (sub->rtp) {
1194                                 res =  ast_rtp_write(sub->rtp, frame);
1195                         }
1196                 }
1197                 ast_mutex_unlock(&sub->lock);
1198         }
1199         return res;
1200 }
1201
1202 static int mgcp_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1203 {
1204         struct mgcp_subchannel *sub = newchan->pvt->pvt;
1205         ast_mutex_lock(&sub->lock);
1206     ast_log(LOG_NOTICE, "mgcp_fixup(%s, %s)\n", oldchan->name, newchan->name);
1207         if (sub->owner != oldchan) {
1208                 ast_mutex_unlock(&sub->lock);
1209                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, sub->owner);
1210                 return -1;
1211         }
1212         sub->owner = newchan;
1213         ast_mutex_unlock(&sub->lock);
1214         return 0;
1215 }
1216
1217 static int mgcp_senddigit(struct ast_channel *ast, char digit)
1218 {
1219         struct mgcp_subchannel *sub = ast->pvt->pvt;
1220         char tmp[4];
1221         tmp[0] = 'D';
1222         tmp[1] = '/';
1223         tmp[2] = digit;
1224         tmp[3] = '\0';
1225         ast_mutex_lock(&sub->lock);
1226         transmit_notify_request(sub, tmp);
1227         ast_mutex_unlock(&sub->lock);
1228         return -1;
1229 }
1230
1231 static char *control2str(int ind) {
1232     switch (ind) {
1233         case AST_CONTROL_HANGUP:
1234             return "Other end has hungup";
1235         case AST_CONTROL_RING:
1236             return "Local ring";
1237         case AST_CONTROL_RINGING:
1238             return "Remote end is ringing";
1239         case AST_CONTROL_ANSWER:
1240             return "Remote end has answered";
1241         case AST_CONTROL_BUSY:
1242             return "Remote end is busy";
1243         case AST_CONTROL_TAKEOFFHOOK:
1244             return "Make it go off hook";
1245         case AST_CONTROL_OFFHOOK:
1246             return "Line is off hook";
1247         case AST_CONTROL_CONGESTION:
1248             return "Congestion (circuits busy)";
1249         case AST_CONTROL_FLASH:
1250             return "Flash hook";
1251         case AST_CONTROL_WINK:
1252             return "Wink";
1253         case AST_CONTROL_OPTION:
1254             return "Set a low-level option";
1255         case AST_CONTROL_RADIO_KEY:
1256             return "Key Radio";
1257         case AST_CONTROL_RADIO_UNKEY:
1258             return "Un-Key Radio";
1259     }
1260     return "UNKNOWN";
1261 }
1262
1263
1264 static int mgcp_indicate(struct ast_channel *ast, int ind)
1265 {
1266         struct mgcp_subchannel *sub = ast->pvt->pvt;
1267         int res = 0;
1268     if (mgcpdebug) {
1269         ast_verbose(VERBOSE_PREFIX_3 "MGCP asked to indicate %d '%s' condition on channel %s\n", ind, control2str(ind), ast->name);
1270     }
1271         ast_mutex_lock(&sub->lock);
1272         switch(ind) {
1273         case AST_CONTROL_RINGING:
1274 #ifdef DLINK_BUGGY_FIRMWARE     
1275                 transmit_notify_request(sub, "rt");
1276 #else
1277                 transmit_notify_request(sub, "G/rt");
1278 #endif          
1279                 break;
1280         case AST_CONTROL_BUSY:
1281                 transmit_notify_request(sub, "L/bz");
1282                 break;
1283         case AST_CONTROL_CONGESTION:
1284                 transmit_notify_request(sub, "G/cg");
1285                 break;
1286         case -1:
1287                 transmit_notify_request(sub, "");
1288                 break;          
1289         default:
1290                 ast_log(LOG_WARNING, "Don't know how to indicate condition %d\n", ind);
1291                 res = -1;
1292         }
1293         ast_mutex_unlock(&sub->lock);
1294         return res;
1295 }
1296
1297 static struct ast_channel *mgcp_new(struct mgcp_subchannel *sub, int state)
1298 {
1299         struct ast_channel *tmp;
1300     struct mgcp_endpoint *i = sub->parent;
1301         int fmt;
1302     i = sub->parent;
1303         tmp = ast_channel_alloc(1);
1304         if (tmp) {
1305                 tmp->nativeformats = i->capability;
1306                 if (!tmp->nativeformats)
1307                         tmp->nativeformats = capability;
1308                 fmt = ast_best_codec(tmp->nativeformats);
1309                 snprintf(tmp->name, sizeof(tmp->name), "MGCP/%s@%s-%d", i->name, i->parent->name, sub->id);
1310                 if (sub->rtp)
1311                         tmp->fds[0] = ast_rtp_fd(sub->rtp);
1312                 tmp->type = type;
1313                 if (i->dtmfmode & MGCP_DTMF_INBAND) {
1314                     i->dsp = ast_dsp_new();
1315                     ast_dsp_set_features(i->dsp,DSP_FEATURE_DTMF_DETECT);
1316             /* SC: this is to prevent clipping of dtmf tones during dsp processing */
1317             ast_dsp_digitmode(i->dsp, DSP_DIGITMODE_NOQUELCH);
1318                 } else {
1319                     i->dsp = NULL;
1320                 }
1321                 ast_setstate(tmp, state);
1322                 if (state == AST_STATE_RING)
1323                         tmp->rings = 1;
1324                 tmp->writeformat = fmt;
1325                 tmp->pvt->rawwriteformat = fmt;
1326                 tmp->readformat = fmt;
1327                 tmp->pvt->rawreadformat = fmt;
1328                 tmp->pvt->pvt = sub;
1329                 tmp->pvt->call = mgcp_call;
1330                 tmp->pvt->hangup = mgcp_hangup;
1331                 tmp->pvt->answer = mgcp_answer;
1332                 tmp->pvt->read = mgcp_read;
1333                 tmp->pvt->write = mgcp_write;
1334                 tmp->pvt->indicate = mgcp_indicate;
1335                 tmp->pvt->fixup = mgcp_fixup;
1336                 tmp->pvt->send_digit = mgcp_senddigit;
1337                 tmp->pvt->bridge = ast_rtp_bridge;
1338                 if (strlen(i->language))
1339                         strncpy(tmp->language, i->language, sizeof(tmp->language)-1);
1340                 if (strlen(i->accountcode))
1341                         strncpy(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode)-1);
1342                 if (i->amaflags)
1343                         tmp->amaflags = i->amaflags;
1344                 sub->owner = tmp;
1345                 ast_mutex_lock(&usecnt_lock);
1346                 usecnt++;
1347                 ast_mutex_unlock(&usecnt_lock);
1348                 ast_update_use_count();
1349                 tmp->callgroup = i->callgroup;
1350                 tmp->pickupgroup = i->pickupgroup;
1351                 strncpy(tmp->call_forward, i->call_forward, sizeof(tmp->call_forward) - 1);
1352                 strncpy(tmp->context, i->context, sizeof(tmp->context)-1);
1353                 strncpy(tmp->exten, i->exten, sizeof(tmp->exten)-1);
1354                 if (!ast_strlen_zero(i->cid_num))
1355                         tmp->cid.cid_num = strdup(i->cid_num);
1356                 if (!ast_strlen_zero(i->cid_name))
1357                         tmp->cid.cid_name = strdup(i->cid_name);
1358                 if (!i->adsi)
1359                         tmp->adsicpe = AST_ADSI_UNAVAILABLE;
1360                 tmp->priority = 1;
1361                 if (state != AST_STATE_DOWN) {
1362                         if (ast_pbx_start(tmp)) {
1363                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
1364                                 ast_hangup(tmp);
1365                                 tmp = NULL;
1366                         }
1367                 }
1368         /* SC: verbose level check */
1369         if (option_verbose > 2) {
1370             ast_verbose(VERBOSE_PREFIX_3 "MGCP mgcp_new(%s) created in state: %s\n", tmp->name, ast_state2str(state));
1371         }
1372         } else {
1373                 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
1374     }
1375         return tmp;
1376 }
1377
1378 static char* get_sdp_by_line(char* line, char *name, int nameLen) {
1379   if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') {
1380     char* r = line + nameLen + 1;
1381     while (*r && (*r < 33)) ++r;
1382     return r;
1383   }
1384
1385   return "";
1386 }
1387
1388 static char *get_sdp(struct mgcp_request *req, char *name) {
1389   int x;
1390   int len = strlen(name);
1391   char *r;
1392
1393   for (x=0; x<req->lines; x++) {
1394     r = get_sdp_by_line(req->line[x], name, len);
1395     if (r[0] != '\0') return r;
1396   }
1397   return "";
1398 }
1399
1400 static void sdpLineNum_iterator_init(int* iterator) {
1401   *iterator = 0;
1402 }
1403
1404 static char* get_sdp_iterate(int* iterator,
1405                              struct mgcp_request *req, char *name) {
1406   int len = strlen(name);
1407   char *r;
1408   while (*iterator < req->lines) {
1409     r = get_sdp_by_line(req->line[(*iterator)++], name, len);
1410     if (r[0] != '\0') return r;
1411   }
1412   return "";
1413 }
1414
1415 static char *__get_header(struct mgcp_request *req, char *name, int *start)
1416 {
1417         int x;
1418         int len = strlen(name);
1419         char *r;
1420         for (x=*start;x<req->headers;x++) {
1421                 if (!strncasecmp(req->header[x], name, len) && 
1422                                 (req->header[x][len] == ':')) {
1423                                         r = req->header[x] + len + 1;
1424                                         while(*r && (*r < 33))
1425                                                         r++;
1426                                         *start = x+1;
1427                                         return r;
1428                 }
1429         }
1430         /* Don't return NULL, so get_header is always a valid pointer */
1431         return "";
1432 }
1433
1434 static char *get_header(struct mgcp_request *req, char *name)
1435 {
1436         int start = 0;
1437         return __get_header(req, name, &start);
1438 }
1439
1440 /* SC: get comma separated value */
1441 static char *get_csv(char *c, int *len, char **next) 
1442 {
1443     char *s;
1444
1445     *next = NULL, *len = 0;
1446     if (!c) return NULL;
1447
1448     while(*c && (*c < 33 || *c == ','))
1449         c++;
1450     
1451     s = c;
1452     while(*c && (*c >= 33 && *c != ','))
1453         c++, (*len)++;
1454     *next = c;
1455     
1456     if (*len == 0)
1457         s = NULL, *next = NULL;
1458     
1459     return s;
1460
1461
1462 static struct mgcp_subchannel *find_subchannel_and_lock(char *name, int msgid, struct sockaddr_in *sin)
1463 {
1464         struct mgcp_endpoint *p = NULL;
1465         struct mgcp_subchannel *sub = NULL;
1466         struct mgcp_gateway *g;
1467         char iabuf[INET_ADDRSTRLEN];
1468         char tmp[256] = "";
1469         char *at = NULL, *c;
1470     int found = 0;
1471         if (name) {
1472                 strncpy(tmp, name, sizeof(tmp) - 1);
1473                 at = strchr(tmp, '@');
1474                 if (!at) {
1475                         ast_log(LOG_NOTICE, "Endpoint '%s' has no at sign!\n", name);
1476                         return NULL;
1477                 }
1478                 *at = '\0';
1479                 at++;
1480         }
1481         ast_mutex_lock(&gatelock);
1482         if (at && (at[0] == '[')) {
1483                 at++;
1484                 c = strrchr(at, ']');
1485                 if (c)
1486                         *c = '\0';
1487         }
1488         g = gateways;
1489         while(g) {
1490                 if ((!name || !strcasecmp(g->name, at)) && 
1491                     (sin || g->addr.sin_addr.s_addr || g->defaddr.sin_addr.s_addr)) {
1492                         /* Found the gateway.  If it's dynamic, save it's address -- now for the endpoint */
1493                         if (sin && g->dynamic && name) {
1494                                 if ((g->addr.sin_addr.s_addr != sin->sin_addr.s_addr) ||
1495                                         (g->addr.sin_port != sin->sin_port)) {
1496                                         memcpy(&g->addr, sin, sizeof(g->addr));
1497                                         if (ast_ouraddrfor(&g->addr.sin_addr, &g->ourip))
1498                                                 memcpy(&g->ourip, &__ourip, sizeof(g->ourip));
1499                                         if (option_verbose > 2)
1500                                                 ast_verbose(VERBOSE_PREFIX_3 "Registered MGCP gateway '%s' at %s port %d\n", g->name, ast_inet_ntoa(iabuf, sizeof(iabuf), g->addr.sin_addr), ntohs(g->addr.sin_port));
1501                                 }
1502                         }
1503             /* SC: not dynamic, check if the name matches */
1504             else if (name) {
1505                 if (strcasecmp(g->name, at)) {
1506                     g = g->next;
1507                     continue;
1508                 }
1509             }
1510             /* SC: not dynamic, no name, check if the addr matches */
1511             else if (!name && sin) {
1512                                 if ((g->addr.sin_addr.s_addr != sin->sin_addr.s_addr) ||
1513                                         (g->addr.sin_port != sin->sin_port)) {
1514                     g = g->next;
1515                     continue;
1516                 }
1517             }
1518             else  {
1519                 g = g->next;
1520                 continue;
1521             }
1522             /* SC */
1523                         p = g->endpoints;
1524                         while(p) {
1525                                 if (option_debug)
1526                         ast_log(LOG_DEBUG, "Searching on %s@%s for subchannel\n", p->name, g->name);
1527                 if (msgid) {
1528 #if 0 /* SC: new transport mech */
1529                     sub = p->sub;
1530                     do {
1531                                                 if (option_debug)
1532                             ast_log(LOG_DEBUG, "Searching on %s@%s-%d for subchannel with lastout: %d\n", p->name, g->name, sub->id, msgid);
1533                         if (sub->lastout == msgid) {
1534                                                         if (option_debug)
1535                                 ast_log(LOG_DEBUG, "Found subchannel sub%d to handle request %d sub->lastout: %d\n", sub->id, msgid, sub->lastout);
1536                             found = 1;
1537                             break;
1538                         }
1539                         sub = sub->next;
1540                     } while (sub != p->sub);
1541                     if (found) {
1542                         break;
1543                     }
1544 #endif
1545                     /* SC */
1546                     sub = p->sub;
1547                     found = 1;
1548                     /* SC */
1549                     break;
1550                 } else if (name && !strcasecmp(p->name, tmp)) {
1551                     ast_log(LOG_DEBUG, "Coundn't determine subchannel, assuming current master %s@%s-%d\n", 
1552                             p->name, g->name, p->sub->id);
1553                     sub = p->sub;
1554                     found = 1;
1555                     break;
1556                 }
1557                 p = p->next;
1558                         }
1559                         if (sub && found) {
1560                                 ast_mutex_lock(&sub->lock);
1561                                 break;
1562             }
1563                 }
1564                 g = g->next;
1565         }
1566         ast_mutex_unlock(&gatelock);
1567         if (!sub) {
1568                 if (name) {
1569                         if (g)
1570                                 ast_log(LOG_NOTICE, "Endpoint '%s' not found on gateway '%s'\n", tmp,at);
1571                         else
1572                                 ast_log(LOG_NOTICE, "Gateway '%s' (and thus its endpoint '%s') does not exist\n", at, tmp);
1573                 } 
1574         }
1575         return sub;
1576 }
1577
1578 static void parse(struct mgcp_request *req)
1579 {
1580         /* Divide fields by NULL's */
1581         char *c;
1582         int f = 0;
1583         c = req->data;
1584
1585         /* First header starts immediately */
1586         req->header[f] = c;
1587         while(*c) {
1588                 if (*c == '\n') {
1589                         /* We've got a new header */
1590                         *c = 0;
1591
1592 #if 0
1593                         printf("Header: %s (%d)\n", req->header[f], strlen(req->header[f]));
1594 #endif                  
1595                         if (!strlen(req->header[f])) {
1596                                 /* Line by itself means we're now in content */
1597                                 c++;
1598                                 break;
1599                         }
1600                         if (f >= MGCP_MAX_HEADERS - 1) {
1601                                 ast_log(LOG_WARNING, "Too many MGCP headers...\n");
1602                         } else
1603                                 f++;
1604                         req->header[f] = c + 1;
1605                 } else if (*c == '\r') {
1606                         /* Ignore but eliminate \r's */
1607                         *c = 0;
1608                 }
1609                 c++;
1610         }
1611         /* Check for last header */
1612         if (strlen(req->header[f])) 
1613                 f++;
1614         req->headers = f;
1615         /* Now we process any mime content */
1616         f = 0;
1617         req->line[f] = c;
1618         while(*c) {
1619                 if (*c == '\n') {
1620                         /* We've got a new line */
1621                         *c = 0;
1622 #if 0
1623                         printf("Line: %s (%d)\n", req->line[f], strlen(req->line[f]));
1624 #endif                  
1625                         if (f >= MGCP_MAX_LINES - 1) {
1626                                 ast_log(LOG_WARNING, "Too many SDP lines...\n");
1627                         } else
1628                                 f++;
1629                         req->line[f] = c + 1;
1630                 } else if (*c == '\r') {
1631                         /* Ignore and eliminate \r's */
1632                         *c = 0;
1633                 }
1634                 c++;
1635         }
1636         /* Check for last line */
1637         if (strlen(req->line[f])) 
1638                 f++;
1639         req->lines = f;
1640         /* Parse up the initial header */
1641         c = req->header[0];
1642         while(*c && *c < 33) c++;
1643         /* First the verb */
1644         req->verb = c;
1645         while(*c && (*c > 32)) c++;
1646         if (*c) {
1647                 *c = '\0';
1648                 c++;
1649                 while(*c && (*c < 33)) c++;
1650                 req->identifier = c;
1651                 while(*c && (*c > 32)) c++;
1652                 if (*c) {
1653                         *c = '\0';
1654                         c++;
1655                         while(*c && (*c < 33)) c++;
1656                         req->endpoint = c;
1657                         while(*c && (*c > 32)) c++;
1658                         if (*c) {
1659                                 *c = '\0';
1660                                 c++;
1661                                 while(*c && (*c < 33)) c++;
1662                                 req->version = c;
1663                                 while(*c && (*c > 32)) c++;
1664                                 while(*c && (*c < 33)) c++;
1665                                 while(*c && (*c > 32)) c++;
1666                                 *c = '\0';
1667                         }
1668                 }
1669         }
1670                 
1671         if (mgcpdebug) {
1672                 ast_verbose("Verb: '%s', Identifier: '%s', Endpoint: '%s', Version: '%s'\n",
1673                     req->verb, req->identifier, req->endpoint, req->version);
1674                 ast_verbose("%d headers, %d lines\n", req->headers, req->lines);
1675         }
1676         if (*c) 
1677                 ast_log(LOG_WARNING, "Odd content, extra stuff left over ('%s')\n", c);
1678 }
1679
1680 static int process_sdp(struct mgcp_subchannel *sub, struct mgcp_request *req)
1681 {
1682         char *m;
1683         char *c;
1684         char *a;
1685         char host[258];
1686         int len;
1687         int portno;
1688         int peercapability, peerNonCodecCapability;
1689         struct sockaddr_in sin;
1690         char *codecs;
1691         struct ast_hostent ahp; struct hostent *hp;
1692         int codec;
1693         int iterator;
1694     struct mgcp_endpoint *p = sub->parent;
1695
1696         /* Get codec and RTP info from SDP */
1697         m = get_sdp(req, "m");
1698         c = get_sdp(req, "c");
1699         if (!strlen(m) || !strlen(c)) {
1700                 ast_log(LOG_WARNING, "Insufficient information for SDP (m = '%s', c = '%s')\n", m, c);
1701                 return -1;
1702         }
1703         if (sscanf(c, "IN IP4 %256s", host) != 1) {
1704                 ast_log(LOG_WARNING, "Invalid host in c= line, '%s'\n", c);
1705                 return -1;
1706         }
1707         /* XXX This could block for a long time, and block the main thread! XXX */
1708         hp = ast_gethostbyname(host, &ahp);
1709         if (!hp) {
1710                 ast_log(LOG_WARNING, "Unable to lookup host in c= line, '%s'\n", c);
1711                 return -1;
1712         }
1713         if (sscanf(m, "audio %d RTP/AVP %n", &portno, &len) != 1) {
1714                 ast_log(LOG_WARNING, "Unable to determine port number for RTP in '%s'\n", m); 
1715                 return -1;
1716         }
1717         sin.sin_family = AF_INET;
1718         memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
1719         sin.sin_port = htons(portno);
1720         ast_rtp_set_peer(sub->rtp, &sin);
1721 #if 0
1722         printf("Peer RTP is at port %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
1723 #endif  
1724         /* Scan through the RTP payload types specified in a "m=" line: */
1725     ast_rtp_pt_clear(sub->rtp);
1726         codecs = m + len;
1727         while(strlen(codecs)) {
1728                 if (sscanf(codecs, "%d %n", &codec, &len) != 1) {
1729                         ast_log(LOG_WARNING, "Error in codec string '%s'\n", codecs);
1730                         return -1;
1731                 }
1732                 ast_rtp_set_m_type(sub->rtp, codec);
1733                 codecs += len;
1734         }
1735
1736         /* Next, scan through each "a=rtpmap:" line, noting each */
1737         /* specified RTP payload type (with corresponding MIME subtype): */
1738         sdpLineNum_iterator_init(&iterator);
1739         while ((a = get_sdp_iterate(&iterator, req, "a"))[0] != '\0') {
1740           char* mimeSubtype = strdup(a); /* ensures we have enough space */
1741           if (sscanf(a, "rtpmap: %u %[^/]/", &codec, mimeSubtype) != 2) continue;
1742           /* Note: should really look at the 'freq' and '#chans' params too */
1743           ast_rtp_set_rtpmap_type(sub->rtp, codec, "audio", mimeSubtype);
1744           free(mimeSubtype);
1745         }
1746
1747         /* Now gather all of the codecs that were asked for: */
1748         ast_rtp_get_current_formats(sub->rtp,
1749                                 &peercapability, &peerNonCodecCapability);
1750         p->capability = capability & peercapability;
1751         if (mgcpdebug) {
1752                 ast_verbose("Capabilities: us - %d, them - %d, combined - %d\n",
1753                     capability, peercapability, p->capability);
1754                 ast_verbose("Non-codec capabilities: us - %d, them - %d, combined - %d\n",
1755                     nonCodecCapability, peerNonCodecCapability, p->nonCodecCapability);
1756         }
1757         if (!p->capability) {
1758                 ast_log(LOG_WARNING, "No compatible codecs!\n");
1759                 return -1;
1760         }
1761         return 0;
1762         
1763 }
1764
1765 static int add_header(struct mgcp_request *req, char *var, char *value)
1766 {
1767         if (req->len >= sizeof(req->data) - 4) {
1768                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
1769                 return -1;
1770         }
1771         if (req->lines) {
1772                 ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n");
1773                 return -1;
1774         }
1775         req->header[req->headers] = req->data + req->len;
1776         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s: %s\r\n", var, value);
1777         req->len += strlen(req->header[req->headers]);
1778         if (req->headers < MGCP_MAX_HEADERS)
1779                 req->headers++;
1780         else {
1781                 ast_log(LOG_WARNING, "Out of header space\n");
1782                 return -1;
1783         }
1784         return 0;       
1785 }
1786
1787 static int add_line(struct mgcp_request *req, char *line)
1788 {
1789         if (req->len >= sizeof(req->data) - 4) {
1790                 ast_log(LOG_WARNING, "Out of space, can't add anymore\n");
1791                 return -1;
1792         }
1793         if (!req->lines) {
1794                 /* Add extra empty return */
1795                 snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n");
1796                 req->len += strlen(req->data + req->len);
1797         }
1798         req->line[req->lines] = req->data + req->len;
1799         snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line);
1800         req->len += strlen(req->line[req->lines]);
1801         if (req->lines < MGCP_MAX_LINES)
1802                 req->lines++;
1803         else {
1804                 ast_log(LOG_WARNING, "Out of line space\n");
1805                 return -1;
1806         }
1807         return 0;       
1808 }
1809
1810 static int init_resp(struct mgcp_request *req, char *resp, struct mgcp_request *orig, char *resprest)
1811 {
1812         /* Initialize a response */
1813         if (req->headers || req->len) {
1814                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
1815                 return -1;
1816         }
1817         req->header[req->headers] = req->data + req->len;
1818         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %s %s\r\n", resp, orig->identifier, resprest);
1819         req->len += strlen(req->header[req->headers]);
1820         if (req->headers < MGCP_MAX_HEADERS)
1821                 req->headers++;
1822         else
1823                 ast_log(LOG_WARNING, "Out of header space\n");
1824         return 0;
1825 }
1826
1827 static int init_req(struct mgcp_endpoint *p, struct mgcp_request *req, char *verb)
1828 {
1829         /* Initialize a response */
1830         if (req->headers || req->len) {
1831                 ast_log(LOG_WARNING, "Request already initialized?!?\n");
1832                 return -1;
1833         }
1834         req->header[req->headers] = req->data + req->len;
1835     /* SC: check if we need brackets around the gw name */
1836     if (p->parent->isnamedottedip)
1837         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %d %s@[%s] MGCP 1.0\r\n", verb, oseq, p->name, p->parent->name);
1838     else
1839         snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %d %s@%s MGCP 1.0\r\n", verb, oseq, p->name, p->parent->name);
1840         req->len += strlen(req->header[req->headers]);
1841         if (req->headers < MGCP_MAX_HEADERS)
1842                 req->headers++;
1843         else
1844                 ast_log(LOG_WARNING, "Out of header space\n");
1845         return 0;
1846 }
1847
1848
1849 static int respprep(struct mgcp_request *resp, struct mgcp_endpoint *p, char *msg, struct mgcp_request *req, char *msgrest)
1850 {
1851         memset(resp, 0, sizeof(*resp));
1852         init_resp(resp, msg, req, msgrest);
1853         return 0;
1854 }
1855
1856 static int reqprep(struct mgcp_request *req, struct mgcp_endpoint *p, char *verb)
1857 {
1858         memset(req, 0, sizeof(struct mgcp_request));
1859         oseq++;
1860         if (oseq > 999999999)
1861                 oseq = 1;
1862         init_req(p, req, verb);
1863         return 0;
1864 }
1865
1866 static int transmit_response(struct mgcp_subchannel *sub, char *msg, struct mgcp_request *req, char *msgrest)
1867 {
1868         struct mgcp_request resp;
1869     struct mgcp_endpoint *p = sub->parent;
1870         struct mgcp_response *mgr;
1871         respprep(&resp, p, msg, req, msgrest);
1872         mgr = malloc(sizeof(struct mgcp_response) + resp.len + 1);
1873         if (mgr) {
1874                 /* Store MGCP response in case we have to retransmit */
1875                 memset(mgr, 0, sizeof(struct mgcp_response));
1876                 sscanf(req->identifier, "%d", &mgr->seqno);
1877                 time(&mgr->whensent);
1878                 mgr->len = resp.len;
1879                 memcpy(mgr->buf, resp.data, resp.len);
1880                 mgr->buf[resp.len] = '\0';
1881                 mgr->next = p->parent->responses;
1882                 p->parent->responses = mgr;
1883         }
1884         return send_response(sub, &resp);
1885 }
1886
1887
1888 static int add_sdp(struct mgcp_request *resp, struct mgcp_subchannel *sub, struct ast_rtp *rtp)
1889 {
1890         int len;
1891         int codec;
1892         char costr[80];
1893         struct sockaddr_in sin;
1894         char v[256];
1895         char s[256];
1896         char o[256];
1897         char c[256];
1898         char t[256];
1899         char m[256] = "";
1900         char a[1024] = "";
1901         char iabuf[INET_ADDRSTRLEN];
1902         int x;
1903         struct sockaddr_in dest;
1904     struct mgcp_endpoint *p = sub->parent;
1905         /* XXX We break with the "recommendation" and send our IP, in order that our
1906                peer doesn't have to ast_gethostbyname() us XXX */
1907         len = 0;
1908         if (!sub->rtp) {
1909                 ast_log(LOG_WARNING, "No way to add SDP without an RTP structure\n");
1910                 return -1;
1911         }
1912         ast_rtp_get_us(sub->rtp, &sin);
1913         if (rtp) {
1914                 ast_rtp_get_peer(rtp, &dest);
1915         } else {
1916                 if (sub->tmpdest.sin_addr.s_addr) {
1917                         dest.sin_addr = sub->tmpdest.sin_addr;
1918                         dest.sin_port = sub->tmpdest.sin_port;
1919                         /* Reset temporary destination */
1920                         memset(&sub->tmpdest, 0, sizeof(sub->tmpdest));
1921                 } else {
1922                         dest.sin_addr = p->parent->ourip;
1923                         dest.sin_port = sin.sin_port;
1924                 }
1925         }
1926         if (mgcpdebug) {
1927                 ast_verbose("We're at %s port %d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), p->parent->ourip), ntohs(sin.sin_port));       
1928     }
1929         snprintf(v, sizeof(v), "v=0\r\n");
1930         snprintf(o, sizeof(o), "o=root %d %d IN IP4 %s\r\n", getpid(), getpid(), ast_inet_ntoa(iabuf, sizeof(iabuf), dest.sin_addr));
1931         snprintf(s, sizeof(s), "s=session\r\n");
1932         snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", ast_inet_ntoa(iabuf, sizeof(iabuf), dest.sin_addr));
1933         snprintf(t, sizeof(t), "t=0 0\r\n");
1934         snprintf(m, sizeof(m), "m=audio %d RTP/AVP", ntohs(dest.sin_port));
1935         for (x = 1; x <= AST_FORMAT_MAX_AUDIO; x <<= 1) {
1936                 if (p->capability & x) {
1937                         if (mgcpdebug) {
1938                                 ast_verbose("Answering with capability %d\n", x);
1939             }
1940                         codec = ast_rtp_lookup_code(sub->rtp, 1, x);
1941             if (codec > -1) {
1942                                 snprintf(costr, sizeof(costr), " %d", codec);
1943                                 strncat(m, costr, sizeof(m) - strlen(m) - 1);
1944                                 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, x));
1945                                 strncat(a, costr, sizeof(a) - strlen(a) - 1);
1946                         }
1947                 }
1948         }
1949         for (x = 1; x <= AST_RTP_MAX; x <<= 1) {
1950         if (p->nonCodecCapability & x) {
1951             if (mgcpdebug) {
1952                 ast_verbose("Answering with non-codec capability %d\n", x);
1953             }
1954             codec = ast_rtp_lookup_code(sub->rtp, 0, x);
1955             if (codec > -1) {
1956                 snprintf(costr, sizeof(costr), " %d", codec);
1957                 strncat(m, costr, sizeof(m) - strlen(m) - 1);
1958                 snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(0, x));
1959                 strncat(a, costr, sizeof(a) - strlen(a) - 1);
1960                 if (x == AST_RTP_DTMF) {
1961                   /* Indicate we support DTMF...  Not sure about 16, but MSN supports it so dang it, we will too... */
1962                   snprintf(costr, sizeof costr, "a=fmtp:%d 0-16\r\n", codec);
1963                   strncat(a, costr, sizeof(a) - strlen(a) - 1);
1964                 }
1965             }
1966         }
1967     }
1968         strncat(m, "\r\n", sizeof(m) - strlen(m) - 1);
1969         len = strlen(v) + strlen(s) + strlen(o) + strlen(c) + strlen(t) + strlen(m) + strlen(a);
1970         snprintf(costr, sizeof(costr), "%d", len);
1971         add_line(resp, v);
1972         add_line(resp, o);
1973         add_line(resp, s);
1974         add_line(resp, c);
1975         add_line(resp, t);
1976         add_line(resp, m);
1977         add_line(resp, a);
1978         return 0;
1979 }
1980
1981 static int transmit_modify_with_sdp(struct mgcp_subchannel *sub, struct ast_rtp *rtp, int codecs)
1982 {
1983         struct mgcp_request resp;
1984         char local[256];
1985         char tmp[80];
1986         int x;
1987         int capability;
1988     struct mgcp_endpoint *p = sub->parent;
1989         capability = p->capability;
1990         if (codecs)
1991                 capability = codecs;
1992         if (!strlen(sub->cxident) && rtp) {
1993                 /* We don't have a CXident yet, store the destination and
1994                    wait a bit */
1995                 ast_rtp_get_peer(rtp, &sub->tmpdest);
1996                 return 0;
1997         }
1998         snprintf(local, sizeof(local), "p:20");
1999         for (x=1;x<= AST_FORMAT_MAX_AUDIO; x <<= 1) {
2000                 if (p->capability & x) {
2001                         snprintf(tmp, sizeof(tmp), ", a:%s", ast_rtp_lookup_mime_subtype(1, x));
2002                         strncat(local, tmp, sizeof(local) - strlen(local) - 1);
2003                 }
2004         }
2005         reqprep(&resp, p, "MDCX");
2006         add_header(&resp, "C", sub->callid);
2007         add_header(&resp, "L", local);
2008         add_header(&resp, "M", mgcp_cxmodes[sub->cxmode]);
2009     /* SC: X header should not be sent. kept for compatibility */
2010         add_header(&resp, "X", sub->txident);
2011         add_header(&resp, "I", sub->cxident);
2012         /*add_header(&resp, "S", "");*/
2013         ast_rtp_offered_from_local(sub->rtp, 0);
2014         add_sdp(&resp, sub, rtp);
2015     /* SC: fill in new fields */
2016     resp.cmd = MGCP_CMD_MDCX;
2017     resp.trid = oseq;
2018         return send_request(p, sub, &resp, oseq); /* SC */
2019 }
2020
2021 static int transmit_connect_with_sdp(struct mgcp_subchannel *sub, struct ast_rtp *rtp)
2022 {
2023         struct mgcp_request resp;
2024         char local[256];
2025         char tmp[80];
2026         int x;
2027     struct mgcp_endpoint *p = sub->parent;
2028
2029         snprintf(local, sizeof(local), "p:20");
2030         for (x=1;x<= AST_FORMAT_MAX_AUDIO; x <<= 1) {
2031                 if (p->capability & x) {
2032                         snprintf(tmp, sizeof(tmp), ", a:%s", ast_rtp_lookup_mime_subtype(1, x));
2033                         strncat(local, tmp, sizeof(local) - strlen(local) - 1);
2034                 }
2035         }
2036     if (mgcpdebug) {
2037         ast_verbose(VERBOSE_PREFIX_3 "Creating connection for %s@%s-%d in cxmode: %s callid: %s\n", 
2038                     p->name, p->parent->name, sub->id, mgcp_cxmodes[sub->cxmode], sub->callid);
2039     }
2040         reqprep(&resp, p, "CRCX");
2041         add_header(&resp, "C", sub->callid);
2042         add_header(&resp, "L", local);
2043         add_header(&resp, "M", mgcp_cxmodes[sub->cxmode]);
2044     /* SC: X header should not be sent. kept for compatibility */
2045         add_header(&resp, "X", sub->txident);
2046         /*add_header(&resp, "S", "");*/
2047         ast_rtp_offered_from_local(sub->rtp, 1);
2048         add_sdp(&resp, sub, rtp);
2049     /* SC: fill in new fields */
2050     resp.cmd = MGCP_CMD_CRCX;
2051     resp.trid = oseq;
2052         return send_request(p, sub, &resp, oseq);  /* SC */
2053 }
2054
2055 static int transmit_notify_request(struct mgcp_subchannel *sub, char *tone)
2056 {
2057         struct mgcp_request resp;
2058     struct mgcp_endpoint *p = sub->parent;
2059
2060     if (mgcpdebug) {
2061         ast_verbose(VERBOSE_PREFIX_3 "MGCP Asked to indicate tone: %s on  %s@%s-%d in cxmode: %s\n", 
2062                     tone, p->name, p->parent->name, sub->id, mgcp_cxmodes[sub->cxmode]);
2063     }
2064         strncpy(p->curtone, tone, sizeof(p->curtone) - 1);
2065         reqprep(&resp, p, "RQNT");
2066         add_header(&resp, "X", p->rqnt_ident); /* SC */
2067     switch (p->hookstate) {
2068             case MGCP_ONHOOK:
2069             add_header(&resp, "R", "L/hd(N)");
2070             break;
2071         case MGCP_OFFHOOK:
2072             add_header(&resp, "R", (sub->rtp && (p->dtmfmode & MGCP_DTMF_INBAND)) ? "L/hu(N),L/hf(N)" : "L/hu(N),L/hf(N),D/[0-9#*](N)");
2073             break;
2074     }
2075     if (strlen(tone)) {
2076         add_header(&resp, "S", tone);
2077     }
2078     /* SC: fill in new fields */
2079     resp.cmd = MGCP_CMD_RQNT;
2080     resp.trid = oseq;
2081         return send_request(p, NULL, &resp, oseq); /* SC */
2082 }
2083
2084 static int transmit_notify_request_with_callerid(struct mgcp_subchannel *sub, char *tone, char *callernum, char *callername)
2085 {
2086         struct mgcp_request resp;
2087         char tone2[256];
2088         char *l, *n;
2089         time_t t;
2090         struct tm tm;
2091     struct mgcp_endpoint *p = sub->parent;
2092         
2093         time(&t);
2094         localtime_r(&t,&tm);
2095         n = callername;
2096         l = callernum;
2097         if (!n)
2098                 n = "";
2099         if (!l)
2100                 l = "";
2101
2102     /* Keep track of last callerid for blacklist and callreturn */
2103     strncpy(p->lastcallerid, l, sizeof(p->lastcallerid) - 1);
2104
2105         snprintf(tone2, sizeof(tone2), "%s,L/ci(%02d/%02d/%02d/%02d,%s,%s)", tone, 
2106                         tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, l, n);
2107         strncpy(p->curtone, tone, sizeof(p->curtone) - 1);
2108         reqprep(&resp, p, "RQNT");
2109         add_header(&resp, "X", p->rqnt_ident); /* SC */
2110     switch (p->hookstate) {
2111             case MGCP_ONHOOK:
2112             add_header(&resp, "R", "L/hd(N)");
2113             break;
2114         case MGCP_OFFHOOK:
2115             add_header(&resp, "R",  (sub->rtp && (p->dtmfmode & MGCP_DTMF_INBAND)) ? "L/hu(N),L/hf(N)" : "L/hu(N),L/hf(N),D/[0-9#*](N)");
2116             break;
2117     }
2118     if (strlen(tone2)) {
2119         add_header(&resp, "S", tone2);
2120     }
2121     if (mgcpdebug) {
2122         ast_verbose(VERBOSE_PREFIX_3 "MGCP Asked to indicate tone: %s on  %s@%s-%d in cxmode: %s\n", 
2123                     tone2, p->name, p->parent->name, sub->id, mgcp_cxmodes[sub->cxmode]);
2124     }
2125     /* SC: fill in new fields */
2126     resp.cmd = MGCP_CMD_RQNT;
2127     resp.trid = oseq;
2128         return send_request(p, NULL, &resp, oseq);  /* SC */
2129 }
2130
2131 static int transmit_modify_request(struct mgcp_subchannel *sub)
2132 {
2133         struct mgcp_request resp;
2134     struct mgcp_endpoint *p = sub->parent;
2135         if (!strlen(sub->cxident)) {
2136                 /* We don't have a CXident yet, store the destination and
2137                    wait a bit */
2138                 return 0;
2139         }
2140     if (mgcpdebug) {
2141         ast_verbose(VERBOSE_PREFIX_3 "Modified %s@%s-%d with new mode: %s on callid: %s\n", 
2142                     p->name, p->parent->name, sub->id, mgcp_cxmodes[sub->cxmode], sub->callid);
2143     }
2144         reqprep(&resp, p, "MDCX");
2145         add_header(&resp, "C", sub->callid);
2146         add_header(&resp, "M", mgcp_cxmodes[sub->cxmode]);
2147     /* SC: X header should not be sent. kept for compatibility */
2148         add_header(&resp, "X", sub->txident);
2149         add_header(&resp, "I", sub->cxident);
2150     switch (sub->parent->hookstate) {
2151             case MGCP_ONHOOK:
2152             add_header(&resp, "R", "L/hd(N)");
2153             break;
2154         case MGCP_OFFHOOK:
2155             add_header(&resp, "R",  (sub->rtp && (p->dtmfmode & MGCP_DTMF_INBAND)) ? "L/hu(N), L/hf(N)" : "L/hu(N),L/hf(N),D/[0-9#*](N)");
2156             break;
2157     }
2158     /* SC: fill in new fields */
2159     resp.cmd = MGCP_CMD_MDCX;
2160     resp.trid = oseq;
2161         return send_request(p, sub, &resp, oseq); /* SC */
2162 }
2163
2164
2165 static int transmit_audit_endpoint(struct mgcp_endpoint *p)
2166 {
2167         struct mgcp_request resp;
2168         reqprep(&resp, p, "AUEP");
2169     /* SC: removed unknown param VS */
2170         /*add_header(&resp, "F", "A,R,D,S,X,N,I,T,O,ES,E,MD,M"); */
2171         add_header(&resp, "F", "A");
2172     /* SC: fill in new fields */
2173     resp.cmd = MGCP_CMD_AUEP;
2174     resp.trid = oseq;
2175         return send_request(p, NULL, &resp, oseq);  /* SC */
2176 }
2177
2178 static int transmit_connection_del(struct mgcp_subchannel *sub)
2179 {
2180     struct mgcp_endpoint *p = sub->parent;
2181         struct mgcp_request resp;
2182     if (mgcpdebug) {
2183         ast_verbose(VERBOSE_PREFIX_3 "Delete connection %s %s@%s-%d with new mode: %s on callid: %s\n", 
2184                     sub->cxident, p->name, p->parent->name, sub->id, mgcp_cxmodes[sub->cxmode], sub->callid);
2185     }
2186         reqprep(&resp, p, "DLCX");
2187     /* SC: check if call id is avail */
2188     if (sub->callid[0])
2189         add_header(&resp, "C", sub->callid);
2190     /* SC: X header should not be sent. kept for compatibility */
2191         add_header(&resp, "X", sub->txident);
2192     /* SC: check if cxident is avail */
2193     if (sub->cxident[0])
2194         add_header(&resp, "I", sub->cxident);
2195     /* SC: fill in new fields */
2196     resp.cmd = MGCP_CMD_DLCX;
2197     resp.trid = oseq;
2198         return send_request(p, sub, &resp, oseq);  /* SC */
2199 }
2200
2201 static int transmit_connection_del_w_params(struct mgcp_endpoint *p, char *callid, char *cxident)
2202 {
2203         struct mgcp_request resp;
2204     if (mgcpdebug) {
2205         ast_verbose(VERBOSE_PREFIX_3 "Delete connection %s %s@%s on callid: %s\n", 
2206                     cxident ? cxident : "", p->name, p->parent->name, callid ? callid : "");
2207     }
2208         reqprep(&resp, p, "DLCX");
2209     /* SC: check if call id is avail */
2210     if (callid && *callid)
2211         add_header(&resp, "C", callid);
2212     /* SC: check if cxident is avail */
2213     if (cxident && *cxident)
2214         add_header(&resp, "I", cxident);
2215     /* SC: fill in new fields */
2216     resp.cmd = MGCP_CMD_DLCX;
2217     resp.trid = oseq;
2218         return send_request(p, p->sub, &resp, oseq);
2219 }
2220
2221 /* SC: cleanup pendng commands */
2222 static void dump_cmd_queues(struct mgcp_endpoint *p, struct mgcp_subchannel *sub) 
2223 {
2224     struct mgcp_request *t, *q;
2225
2226     if (p) {
2227         ast_mutex_lock(&p->rqnt_queue_lock);
2228         for (q = p->rqnt_queue; q; t = q->next, free(q), q=t);
2229         p->rqnt_queue = NULL;
2230         ast_mutex_unlock(&p->rqnt_queue_lock);
2231
2232         ast_mutex_lock(&p->cmd_queue_lock);
2233         for (q = p->cmd_queue; q; t = q->next, free(q), q=t);
2234         p->cmd_queue = NULL;
2235         ast_mutex_unlock(&p->cmd_queue_lock);
2236
2237         ast_mutex_lock(&p->sub->cx_queue_lock);
2238         for (q = p->sub->cx_queue; q; t = q->next, free(q), q=t);
2239         p->sub->cx_queue = NULL;
2240         ast_mutex_unlock(&p->sub->cx_queue_lock);
2241
2242         ast_mutex_lock(&p->sub->next->cx_queue_lock);
2243         for (q = p->sub->next->cx_queue; q; t = q->next, free(q), q=t);
2244         p->sub->next->cx_queue = NULL;
2245         ast_mutex_unlock(&p->sub->next->cx_queue_lock);
2246     }
2247     else if (sub){
2248         ast_mutex_lock(&sub->cx_queue_lock);
2249         for (q = sub->cx_queue; q; t = q->next, free(q), q=t);
2250         sub->cx_queue = NULL;
2251         ast_mutex_unlock(&sub->cx_queue_lock);
2252     }
2253 }
2254
2255
2256 /* SC: remove command transaction from queue */
2257 static struct mgcp_request *find_command(struct mgcp_endpoint *p, struct mgcp_subchannel *sub,
2258                                          struct mgcp_request **queue, ast_mutex_t *l, int ident)
2259 {
2260     struct mgcp_request *prev, *req;
2261         char iabuf[INET_ADDRSTRLEN];
2262
2263     ast_mutex_lock(l);
2264     for (prev = NULL, req = *queue; req; prev = req, req = req->next) {
2265         if (req->trid == ident) {
2266             /* remove from queue */
2267             if (!prev)
2268                 *queue = req->next;
2269             else
2270                 prev->next = req->next;
2271
2272             /* send next pending command */
2273             if (*queue) {
2274                 if (mgcpdebug) {
2275                     ast_verbose("Posting Queued Request:\n%s to %s:%d\n", (*queue)->data, 
2276                                 ast_inet_ntoa(iabuf, sizeof(iabuf), p->parent->addr.sin_addr), ntohs(p->parent->addr.sin_port));
2277                 }
2278
2279                 mgcp_postrequest(p, sub, (*queue)->data, (*queue)->len, (*queue)->trid);
2280             }
2281             break;
2282         }
2283     }
2284     ast_mutex_unlock(l);
2285     return req;
2286 }
2287
2288 /* SC: modified for new transport mechanism */
2289 static void handle_response(struct mgcp_endpoint *p, struct mgcp_subchannel *sub,  
2290                             int result, unsigned int ident, struct mgcp_request *resp)
2291 {
2292     char *c;
2293     struct mgcp_request *req;
2294     struct mgcp_gateway *gw = p->parent;
2295
2296     if (result < 200) {
2297         /* provisional response */
2298         return;
2299     }
2300
2301         if (p->slowsequence) 
2302                 req = find_command(p, sub, &p->cmd_queue, &p->cmd_queue_lock, ident);
2303         else if (sub)
2304         req = find_command(p, sub, &sub->cx_queue, &sub->cx_queue_lock, ident);
2305     else if (!(req = find_command(p, sub, &p->rqnt_queue, &p->rqnt_queue_lock, ident)))
2306         req = find_command(p, sub, &p->cmd_queue, &p->cmd_queue_lock, ident);
2307
2308     if (!req) {
2309         if (option_verbose > 2) {
2310             ast_verbose(VERBOSE_PREFIX_3 "No command found on [%s] for transaction %d. Ignoring...\n", 
2311                         gw->name, ident);
2312         }
2313         return;
2314     }
2315
2316     if (p && (result >= 400) && (result <= 599)) {
2317         switch (result) {
2318             case 401:
2319                 p->hookstate = MGCP_OFFHOOK;
2320                 break;
2321             case 402:
2322                 p->hookstate = MGCP_ONHOOK;
2323                 break;
2324             case 406:
2325                 ast_log(LOG_NOTICE, "Transaction %d timed out\n", ident);
2326                 break;
2327             case 407:
2328                 ast_log(LOG_NOTICE, "Transaction %d aborted\n", ident);
2329                 break;
2330         }
2331         if (sub)
2332         {
2333             if (sub->owner) {
2334                 ast_log(LOG_NOTICE, "Terminating on result %d from %s@%s-%d\n", 
2335                         result, p->name, p->parent->name, sub ? sub->id:-1);
2336                 mgcp_queue_hangup(sub);
2337             }
2338         }
2339         else {
2340             if (p->sub->next->owner) {
2341                 ast_log(LOG_NOTICE, "Terminating on result %d from %s@%s-%d\n", 
2342                         result, p->name, p->parent->name, sub ? sub->id:-1);
2343                 mgcp_queue_hangup(p->sub);
2344             }
2345
2346             if (p->sub->owner) {
2347                 ast_log(LOG_NOTICE, "Terminating on result %d from %s@%s-%d\n", 
2348                         result, p->name, p->parent->name, sub ? sub->id:-1);
2349                 mgcp_queue_hangup(p->sub);
2350             }
2351
2352             dump_cmd_queues(p, NULL);
2353         }
2354     }
2355
2356     if (resp) {
2357         if (req->cmd == MGCP_CMD_CRCX) {
2358             if ((c = get_header(resp, "I"))) {
2359                 if (strlen(c) && sub) {
2360                     /* SC: if we are hanging up do not process this conn. */
2361                     if (sub->owner) {
2362                         if (strlen(sub->cxident)) {
2363                             if (strcasecmp(c, sub->cxident)) {
2364                                 ast_log(LOG_WARNING, "Subchannel already has a cxident. sub->cxident: %s requested %s\n", sub->cxident, c);
2365                             }
2366                         }
2367                         strncpy(sub->cxident, c, sizeof(sub->cxident) - 1);
2368                         if (sub->tmpdest.sin_addr.s_addr) {
2369                             transmit_modify_with_sdp(sub, NULL, 0);
2370                         }
2371                     }
2372                     else {
2373                         /* XXX SC: delete this one
2374                            callid and conn id may already be lost. 
2375                            so the following del conn may have a side effect of 
2376                            cleaning up the next subchannel */
2377                         transmit_connection_del(sub);
2378                     }
2379                 }
2380             }
2381         }
2382
2383         if (req->cmd == MGCP_CMD_AUEP) {
2384             /* SC: check stale connection ids */
2385             if ((c = get_header(resp, "I"))) {
2386                 char *v, *n;
2387                 int len;
2388                 while ((v = get_csv(c, &len, &n))) {
2389                     if (len) {
2390                         if(strncasecmp(v, p->sub->cxident, len) &&
2391                            strncasecmp(v, p->sub->next->cxident, len)) {
2392                             /* connection id not found. delete it */
2393                             char cxident[80];
2394                             memcpy(cxident, v, len);
2395                             cxident[len] = '\0';
2396                             if (option_verbose > 2) {
2397                                 ast_verbose(VERBOSE_PREFIX_3 "Non existing connection id %s on %s@%s \n", 
2398                                             cxident, p->name, gw->name);
2399                             }
2400                             transmit_connection_del_w_params(p, NULL, cxident);
2401                         }
2402                     }
2403                     c = n;
2404                 }
2405             }
2406
2407             /* Try to determine the hookstate returned from an audit endpoint command */
2408             if ((c = get_header(resp, "ES"))) {
2409                 if (strlen(c)) {
2410                     if (strstr(c, "hu")) {
2411                         if (p->hookstate != MGCP_ONHOOK) {
2412                             /* SC: XXX cleanup if we think we are offhook XXX */
2413                             if ((p->sub->owner || p->sub->next->owner ) && 
2414                                 p->hookstate == MGCP_OFFHOOK)
2415                                                 mgcp_queue_hangup(sub);
2416                             p->hookstate = MGCP_ONHOOK;
2417
2418                             /* SC: update the requested events according to the new hookstate */
2419                             transmit_notify_request(p->sub, "");
2420
2421                             /* SC: verbose level check */
2422                             if (option_verbose > 2) {
2423                                 ast_verbose(VERBOSE_PREFIX_3 "Setting hookstate of %s@%s to ONHOOK\n", p->name, gw->name);
2424                             }
2425                         }
2426                     } else if (strstr(c, "hd")) {
2427                         if (p->hookstate != MGCP_OFFHOOK) {
2428                             p->hookstate = MGCP_OFFHOOK;
2429
2430                             /* SC: update the requested events according to the new hookstate */
2431                             transmit_notify_request(p->sub, "");
2432
2433                             /* SC: verbose level check */
2434                             if (option_verbose > 2) {
2435                                 ast_verbose(VERBOSE_PREFIX_3 "Setting hookstate of %s@%s to OFFHOOK\n", p->name, gw->name);
2436                             }
2437                         }
2438                     }
2439                 }
2440            }
2441         }
2442
2443         if (resp && resp->lines) {
2444             /* SC: do not process sdp if we are hanging up. this may be a late response */
2445             if (sub && sub->owner) {
2446                 if (!sub->rtp)
2447                     start_rtp(sub);
2448                 if (sub->rtp)
2449                     process_sdp(sub, resp);
2450             }
2451         }
2452     }
2453
2454     free(req);
2455 }
2456
2457 static void start_rtp(struct mgcp_subchannel *sub)
2458 {
2459                 ast_mutex_lock(&sub->lock);
2460         /* SC: check again to be on the safe side */
2461         if (sub->rtp) {
2462             ast_rtp_destroy(sub->rtp);
2463             sub->rtp = NULL;
2464         }
2465                 /* Allocate the RTP now */
2466                 sub->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, bindaddr.sin_addr);
2467                 if (sub->rtp && sub->owner)
2468                         sub->owner->fds[0] = ast_rtp_fd(sub->rtp);
2469                 if (sub->rtp)
2470                         ast_rtp_setnat(sub->rtp, sub->nat);
2471 #if 0
2472                 ast_rtp_set_callback(p->rtp, rtpready);
2473                 ast_rtp_set_data(p->rtp, p);
2474 #endif          
2475                 /* Make a call*ID */
2476         snprintf(sub->callid, sizeof(sub->callid), "%08x%s", rand(), sub->txident);
2477                 /* Transmit the connection create */
2478                 transmit_connect_with_sdp(sub, NULL);
2479                 ast_mutex_unlock(&sub->lock);
2480 }
2481
2482 static void *mgcp_ss(void *data)
2483 {
2484         struct ast_channel *chan = data;
2485         struct mgcp_subchannel *sub = chan->pvt->pvt;
2486         struct mgcp_endpoint *p = sub->parent;
2487         char exten[AST_MAX_EXTENSION] = "";
2488         int len = 0;
2489         int timeout = firstdigittimeout;
2490         int res;
2491         int getforward=0;
2492     while(len < AST_MAX_EXTENSION-1) {
2493         res = ast_waitfordigit(chan, timeout);
2494         timeout = 0;
2495         if (res < 0) {
2496             ast_log(LOG_DEBUG, "waitfordigit returned < 0...\n");
2497             /*res = tone_zone_play_tone(p->subs[index].zfd, -1);*/
2498                         ast_indicate(chan, -1);
2499             ast_hangup(chan);
2500             return NULL;
2501         } else if (res)  {
2502             exten[len++]=res;
2503             exten[len] = '\0';
2504         }
2505         if (!ast_ignore_pattern(chan->context, exten)) {
2506             /*res = tone_zone_play_tone(p->subs[index].zfd, -1);*/
2507                         ast_indicate(chan, -1);
2508         } else {
2509             /* XXX Redundant?  We should already be playing dialtone */
2510             /*tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALTONE);*/
2511             transmit_notify_request(sub, "L/dl");
2512         }
2513         if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num)) {
2514             if (!res || !ast_matchmore_extension(chan, chan->context, exten, 1, p->cid_num)) {
2515                 if (getforward) {
2516                     /* Record this as the forwarding extension */
2517                     strncpy(p->call_forward, exten, sizeof(p->call_forward) - 1); 
2518                     if (option_verbose > 2) {
2519                         ast_verbose(VERBOSE_PREFIX_3 "Setting call forward to '%s' on channel %s\n", 
2520                                 p->call_forward, chan->name);
2521                     }
2522                     /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);*/
2523                     transmit_notify_request(sub, "L/sl");
2524                     if (res)
2525                         break;
2526                     usleep(500000);
2527                     /*res = tone_zone_play_tone(p->subs[index].zfd, -1);*/
2528                     ast_indicate(chan, -1);
2529                     sleep(1);
2530                     memset(exten, 0, sizeof(exten));
2531                     /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALTONE);*/
2532                     transmit_notify_request(sub, "L/dl");
2533                     len = 0;
2534                     getforward = 0;
2535                 } else  {
2536                     /*res = tone_zone_play_tone(p->subs[index].zfd, -1);*/
2537                     ast_indicate(chan, -1);
2538                     strncpy(chan->exten, exten, sizeof(chan->exten)-1);
2539                     if (!ast_strlen_zero(p->cid_num)) {
2540                         if (!p->hidecallerid) {
2541                             /* SC: free existing chan->callerid */
2542                             if (chan->cid.cid_num)
2543                                 free(chan->cid.cid_num);
2544                             chan->cid.cid_num = strdup(p->cid_num);
2545                             /* SC: free existing chan->callerid */
2546                             if (chan->cid.cid_name)
2547                                 free(chan->cid.cid_name);
2548                             chan->cid.cid_name = strdup(p->cid_name);
2549                         }
2550                         if (chan->cid.cid_ani)
2551                             free(chan->cid.cid_ani);
2552                         chan->cid.cid_ani = strdup(p->cid_num);
2553                     }
2554                     ast_setstate(chan, AST_STATE_RING);
2555                     /*zt_enable_ec(p);*/
2556                     res = ast_pbx_run(chan);
2557                     if (res) {
2558                         ast_log(LOG_WARNING, "PBX exited non-zero\n");
2559                         /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_CONGESTION);*/
2560                         /*transmit_notify_request(p, "nbz", 1);*/
2561                         transmit_notify_request(sub, "G/cg");
2562                     }
2563                     return NULL;
2564                 }
2565             } else {
2566                 /* It's a match, but they just typed a digit, and there is an ambiguous match,
2567                    so just set the timeout to matchdigittimeout and wait some more */
2568                 timeout = matchdigittimeout;
2569             }
2570         } else if (res == 0) {
2571             ast_log(LOG_DEBUG, "not enough digits (and no ambiguous match)...\n");
2572             /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_CONGESTION);*/
2573             transmit_notify_request(sub, "G/cg");
2574             /*zt_wait_event(p->subs[index].zfd);*/
2575             ast_hangup(chan);
2576             return NULL;
2577         } else if (p->callwaiting && !strcmp(exten, "*70")) {
2578             if (option_verbose > 2) {
2579                 ast_verbose(VERBOSE_PREFIX_3 "Disabling call waiting on %s\n", chan->name);
2580             }
2581             /* Disable call waiting if enabled */
2582             p->callwaiting = 0;
2583             /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);*/
2584             transmit_notify_request(sub, "L/sl");
2585             len = 0;
2586             memset(exten, 0, sizeof(exten));
2587             timeout = firstdigittimeout;
2588                 
2589         } else if (!strcmp(exten,ast_pickup_ext())) {
2590             /* Scan all channels and see if any there
2591              * ringing channqels with that have call groups
2592              * that equal this channels pickup group  
2593              */
2594             if (ast_pickup_call(chan)) {
2595                 ast_log(LOG_WARNING, "No call pickup possible...\n");
2596                 /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_CONGESTION);*/
2597                 transmit_notify_request(sub, "G/cg");
2598             }
2599             ast_hangup(chan);
2600             return NULL;
2601             
2602         } else if (!p->hidecallerid && !strcmp(exten, "*67")) {
2603             if (option_verbose > 2) {
2604                 ast_verbose(VERBOSE_PREFIX_3 "Disabling Caller*ID on %s\n", chan->name);
2605             }
2606             /* Disable Caller*ID if enabled */
2607             p->hidecallerid = 1;
2608             if (chan->cid.cid_num)
2609                 free(chan->cid.cid_num);
2610             chan->cid.cid_num = NULL;
2611             if (chan->cid.cid_name)
2612                 free(chan->cid.cid_name);
2613             chan->cid.cid_name = NULL;
2614             /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);*/
2615             transmit_notify_request(sub, "L/sl");
2616             len = 0;
2617             memset(exten, 0, sizeof(exten));
2618             timeout = firstdigittimeout;
2619         } else if (p->callreturn && !strcmp(exten, "*69")) {
2620             res = 0;
2621             if (strlen(p->lastcallerid)) {
2622                 res = ast_say_digit_str(chan, p->lastcallerid, "", chan->language);
2623             }
2624             if (!res)
2625                 /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);*/
2626                 transmit_notify_request(sub, "L/sl");
2627             break;
2628         } else if (!strcmp(exten, "*78")) {
2629             /* Do not disturb */
2630             if (option_verbose > 2) {
2631                 ast_verbose(VERBOSE_PREFIX_3 "Enabled DND on channel %s\n", chan->name);
2632             }
2633             /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);*/
2634             transmit_notify_request(sub, "L/sl");
2635             p->dnd = 1;
2636             getforward = 0;
2637             memset(exten, 0, sizeof(exten));
2638             len = 0;
2639         } else if (!strcmp(exten, "*79")) {
2640             /* Do not disturb */
2641             if (option_verbose > 2) {
2642                 ast_verbose(VERBOSE_PREFIX_3 "Disabled DND on channel %s\n", chan->name);
2643             }
2644             /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);*/
2645             transmit_notify_request(sub, "L/sl");
2646             p->dnd = 0;
2647             getforward = 0;
2648             memset(exten, 0, sizeof(exten));
2649             len = 0;
2650         } else if (p->cancallforward && !strcmp(exten, "*72")) {
2651             /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);*/
2652             transmit_notify_request(sub, "L/sl");
2653             getforward = 1;
2654             memset(exten, 0, sizeof(exten));
2655             len = 0;
2656         } else if (p->cancallforward && !strcmp(exten, "*73")) {
2657             if (option_verbose > 2) {
2658                 ast_verbose(VERBOSE_PREFIX_3 "Cancelling call forwarding on channel %s\n", chan->name);
2659             }
2660             /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);*/
2661             transmit_notify_request(sub, "L/sl");
2662             memset(p->call_forward, 0, sizeof(p->call_forward));
2663             getforward = 0;
2664             memset(exten, 0, sizeof(exten));
2665             len = 0;
2666         } else if (!strcmp(exten, ast_parking_ext()) && 
2667                     sub->next->owner &&
2668                     ast_bridged_channel(sub->next->owner)) {
2669             /* This is a three way call, the main call being a real channel, 
2670                 and we're parking the first call. */
2671             ast_masq_park_call(ast_bridged_channel(sub->next->owner), chan, 0, NULL);
2672             if (option_verbose > 2) {
2673                 ast_verbose(VERBOSE_PREFIX_3 "Parking call to '%s'\n", chan->name);
2674             }
2675             break;
2676         } else if (strlen(p->lastcallerid) && !strcmp(exten, "*60")) {
2677             if (option_verbose > 2) {
2678                 ast_verbose(VERBOSE_PREFIX_3 "Blacklisting number %s\n", p->lastcallerid);
2679             }
2680             res = ast_db_put("blacklist", p->lastcallerid, "1");
2681             if (!res) {
2682                 /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);*/
2683                 transmit_notify_request(sub, "L/sl");
2684                 memset(exten, 0, sizeof(exten));
2685                 len = 0;
2686             }
2687         } else if (p->hidecallerid && !strcmp(exten, "*82")) {
2688             if (option_verbose > 2) {
2689                 ast_verbose(VERBOSE_PREFIX_3 "Enabling Caller*ID on %s\n", chan->name);
2690             }
2691             /* Enable Caller*ID if enabled */
2692             p->hidecallerid = 0;
2693             if (chan->cid.cid_num)
2694                 free(chan->cid.cid_num);
2695             if (!ast_strlen_zero(p->cid_num))
2696                 chan->cid.cid_num = strdup(p->cid_num);
2697             if (chan->cid.cid_name)
2698                 free(chan->cid.cid_name);
2699             if (!ast_strlen_zero(p->cid_name))
2700                 chan->cid.cid_name = strdup(p->cid_name);
2701             /*res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);*/
2702             transmit_notify_request(sub, "L/sl");
2703             len = 0;
2704             memset(exten, 0, sizeof(exten));
2705             timeout = firstdigittimeout;
2706         } else if (!ast_canmatch_extension(chan, chan->context, exten, 1, chan->cid.cid_num) &&
2707                         ((exten[0] != '*') || (strlen(exten) > 2))) {
2708             if (option_debug)
2709                 ast_log(LOG_DEBUG, "Can't match %s from '%s' in context %s\n", exten, chan->cid.cid_num ? chan->cid.cid_num : "<Unknown Caller>", chan->context);
2710             break;
2711         }
2712         if (!timeout)
2713             timeout = gendigittimeout;
2714         if (len && !ast_ignore_pattern(chan->context, exten))
2715             /*tone_zone_play_tone(p->subs[index].zfd, -1);*/
2716                         ast_indicate(chan, -1);
2717     }
2718 #if 0
2719         for (;;) {
2720                 res = ast_waitfordigit(chan, to);
2721                 if (!res) {
2722                         ast_log(LOG_DEBUG, "Timeout...\n");
2723                         break;
2724                 }
2725                 if (res < 0) {
2726                         ast_log(LOG_DEBUG, "Got hangup...\n");
2727             ast_hangup(chan);
2728                         break;
2729                 }
2730                 exten[pos++] = res;
2731                 if (!ast_ignore_pattern(chan->context, exten))
2732                         ast_indicate(chan, -1);
2733                 if (ast_matchmore_extension(chan, chan->context, exten, 1, chan->callerid)) {
2734                         if (ast_exists_extension(chan, chan->context, exten, 1, chan->callerid)) 
2735                                 to = 3000;
2736                         else
2737                                 to = 8000;
2738                 } else
2739                         break;
2740         }
2741         if (ast_exists_extension(chan, chan->context, exten, 1, chan->callerid)) {
2742                 strncpy(chan->exten, exten, sizeof(chan->exten) - 1);
2743         if (!p->rtp) {
2744             start_rtp(p);
2745         }
2746                 ast_setstate(chan, AST_STATE_RING);
2747                 chan->rings = 1;
2748                 if (ast_pbx_run(chan)) {
2749                         ast_log(LOG_WARNING, "Unable to launch PBX on %s\n", chan->name);
2750                 } else
2751                         return NULL;
2752         }
2753 #endif
2754         ast_hangup(chan);
2755         return NULL;
2756 }
2757
2758 static int attempt_transfer(struct mgcp_endpoint *p)
2759 {
2760     /* *************************
2761      * I hope this works.
2762      * Copied out of chan_zap
2763      * Cross your fingers
2764      * *************************/
2765
2766         /* In order to transfer, we need at least one of the channels to
2767            actually be in a call bridge.  We can't conference two applications
2768            together (but then, why would we want to?) */
2769         if (ast_bridged_channel(p->sub->owner)) {
2770                 /* The three-way person we're about to transfer to could still be in MOH, so
2771                    stop if now if appropriate */
2772                 if (ast_bridged_channel(p->sub->next->owner))
2773                         ast_moh_stop(ast_bridged_channel(p->sub->next->owner));
2774                 if (p->sub->owner->_state == AST_STATE_RINGING) {
2775                         ast_indicate(ast_bridged_channel(p->sub->next->owner), AST_CONTROL_RINGING);
2776                 }
2777                 if (ast_channel_masquerade(p->sub->next->owner, ast_bridged_channel(p->sub->owner))) {
2778                         ast_log(LOG_WARNING, "Unable to masquerade %s as %s\n",
2779                                         ast_bridged_channel(p->sub->owner)->name, p->sub->next->owner->name);
2780                         return -1;
2781                 }
2782                 /* Orphan the channel */
2783                 unalloc_sub(p->sub->next);
2784         } else if (ast_bridged_channel(p->sub->next->owner)) {
2785                 if (p->sub->owner->_state == AST_STATE_RINGING) {
2786                         ast_indicate(ast_bridged_channel(p->sub->next->owner), AST_CONTROL_RINGING);
2787                 }
2788                 ast_moh_stop(ast_bridged_channel(p->sub->next->owner));
2789                 if (ast_channel_masquerade(p->sub->owner, ast_bridged_channel(p->sub->next->owner))) {
2790                         ast_log(LOG_WARNING, "Unable to masquerade %s as %s\n",
2791                                         ast_bridged_channel(p->sub->next->owner)->name, p->sub->owner->name);
2792                         return -1;
2793                 }
2794                 /*swap_subs(p, SUB_THREEWAY, SUB_REAL);*/
2795         if (option_verbose > 2) {
2796             ast_verbose(VERBOSE_PREFIX_3 "Swapping %d for %d on %s@%s\n", p->sub->id, p->sub->next->id, p->name, p->parent->name);
2797         }
2798         p->sub = p->sub->next;
2799                 unalloc_sub(p->sub->next);
2800                 /* Tell the caller not to hangup */
2801                 return 1;
2802         } else {
2803                 ast_log(LOG_DEBUG, "Neither %s nor %s are in a bridge, nothing to transfer\n",
2804                                         p->sub->owner->name, p->sub->next->owner->name);
2805                 p->sub->next->owner->_softhangup |= AST_SOFTHANGUP_DEV;
2806         if (p->sub->next->owner) {
2807             p->sub->next->alreadygone = 1;
2808             mgcp_queue_hangup(p->sub->next);
2809         }
2810         }
2811         return 0;
2812 }
2813
2814 static void handle_hd_hf(struct mgcp_subchannel *sub, char *ev) 
2815 {
2816     struct mgcp_endpoint *p = sub->parent;
2817     struct ast_channel *c;
2818         pthread_t t;
2819         pthread_attr_t attr;
2820         pthread_attr_init(&attr);
2821         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);    
2822
2823     /* Off hook / answer */
2824     if (sub->outgoing) {
2825         /* Answered */
2826         if (sub->owner) {
2827             if (ast_bridged_channel(sub->owner)) {
2828                 ast_moh_stop(ast_bridged_channel(sub->owner));
2829             }
2830             sub->cxmode = MGCP_CX_SENDRECV;
2831             if (!sub->rtp) {
2832                 start_rtp(sub);
2833             } else {
2834                 transmit_modify_request(sub);
2835             }
2836             /*transmit_notify_request(sub, "aw");*/
2837             transmit_notify_request(sub, "");
2838             mgcp_queue_control(sub, AST_CONTROL_ANSWER);
2839         }
2840     } else {
2841         /* Start switch */
2842         /*sub->cxmode = MGCP_CX_SENDRECV;*/
2843         if (!sub->owner) {
2844             if (!sub->rtp) {
2845                 start_rtp(sub);
2846             } else {
2847                 transmit_modify_request(sub);
2848             }
2849             if (p->immediate) {
2850                 /* The channel is immediately up.  Start right away */
2851 #ifdef DLINK_BUGGY_FIRMWARE     
2852                                 transmit_notify_request(sub, "rt");
2853 #else
2854                                 transmit_notify_request(sub, "G/rt");
2855 #endif          
2856                 c = mgcp_new(sub, AST_STATE_RING);
2857                 if (!c) {
2858                     ast_log(LOG_WARNING, "Unable to start PBX on channel %s@%s\n", p->name, p->parent->name);
2859                     transmit_notify_request(sub, "G/cg");
2860                     ast_hangup(c);
2861                 }
2862             } else {
2863                 if (has_voicemail(p)) {
2864                     transmit_notify_request(sub, "L/sl");
2865                 } else {
2866                     transmit_notify_request(sub, "L/dl");
2867                 }
2868                 c = mgcp_new(sub, AST_STATE_DOWN);
2869                 if (c) {
2870                     if (ast_pthread_create(&t, &attr, mgcp_ss, c)) {
2871                         ast_log(LOG_WARNING, "Unable to create switch thread: %s\n", strerror(errno));
2872                         ast_hangup(c);
2873                     }
2874                 } else {
2875                     ast_log(LOG_WARNING, "Unable to create channel for %s@%s\n", p->name, p->parent->name);
2876                 }
2877             }
2878         } else {
2879             if (p->hookstate == MGCP_OFFHOOK) {
2880                 ast_log(LOG_WARNING, "Off hook, but already have owner on %s@%s\n", p->name, p->parent->name);
2881             } else {
2882                 ast_log(LOG_WARNING, "On hook, but already have owner on %s@%s\n", p->name, p->parent->name);
2883                 ast_log(LOG_WARNING, "If we're onhook why are we here trying to handle a hd or hf?");
2884             }
2885             if (ast_bridged_channel(sub->owner)) {
2886                 ast_moh_stop(ast_bridged_channel(sub->owner));
2887             }
2888             sub->cxmode = MGCP_CX_SENDRECV;
2889             if (!sub->rtp) {
2890                 start_rtp(sub);
2891             } else {
2892                 transmit_modify_request(sub);
2893             }
2894             /*transmit_notify_request(sub, "aw");*/
2895             transmit_notify_request(sub, "");
2896             /*ast_queue_control(sub->owner, AST_CONTROL_ANSWER);*/
2897         }
2898     }
2899 }
2900
2901 static int handle_request(struct mgcp_subchannel *sub, struct mgcp_request *req, struct sockaddr_in *sin)
2902 {
2903         char *ev, *s;
2904         struct ast_frame f = { 0, };
2905     struct mgcp_endpoint *p = sub->parent;
2906     struct mgcp_gateway *g = NULL;
2907         char iabuf[INET_ADDRSTRLEN];
2908     int res;
2909         if (mgcpdebug) {
2910                 ast_verbose("Handling request '%s' on %s@%s\n", req->verb, p->name, p->parent->name);
2911     }
2912         /* Clear out potential response */
2913         if (!strcasecmp(req->verb, "RSIP")) {
2914                 /* Test if this RSIP request is just a keepalive */
2915                 if(!strcasecmp( get_header(req, "RM"), "X-keepalive")) {
2916                         if (option_verbose > 2)
2917                                 ast_verbose(VERBOSE_PREFIX_3 "Received keepalive request from %s@%s\n", p->name, p->parent->name);
2918                         transmit_response(sub, "200", req, "OK");
2919                 } else {
2920                         dump_queue(p->parent, p);
2921             dump_cmd_queues(p, NULL);
2922                         
2923                         if (option_verbose > 2 && (strcmp(p->name, p->parent->wcardep) != 0)) {
2924                                         ast_verbose(VERBOSE_PREFIX_3 "Resetting interface %s@%s\n", p->name, p->parent->name);
2925                         }
2926                         /* JS: For RSIP on wildcard we reset all endpoints */
2927                         if (!strcmp(p->name, p->parent->wcardep)) {
2928                                 /* Reset all endpoints */
2929                                 struct mgcp_endpoint *tmp_ep;
2930                                                 
2931                                 g = p->parent;
2932                                 tmp_ep = g->endpoints;
2933                                 while (tmp_ep) {
2934                                         /*if ((strcmp(tmp_ep->name, "*") != 0) && (strcmp(tmp_ep->name, "aaln/" "*") != 0)) { */
2935                                         if (strcmp(tmp_ep->name, g->wcardep) != 0) {
2936                                                 struct mgcp_subchannel *tmp_sub, *first_sub;
2937                                                 if (option_verbose > 2) {
2938                                                         ast_verbose(VERBOSE_PREFIX_3 "Resetting interface %s@%s\n", tmp_ep->name, p->parent->name);
2939                                                 }
2940                                                 
2941                                                 first_sub = tmp_ep->sub;
2942                                                 tmp_sub = tmp_ep->sub;
2943                                                 while (tmp_sub) {
2944                                         mgcp_queue_hangup(tmp_sub);
2945                                                         tmp_sub = tmp_sub->next;
2946                                                         if (tmp_sub == first_sub)
2947                                                                 break;
2948                                                 } 
2949                                         }
2950                                         tmp_ep = tmp_ep->next;
2951                                 }
2952                         } else if (sub->owner) {
2953                 mgcp_queue_hangup(sub);
2954                         }
2955                         transmit_response(sub, "200", req, "OK");
2956                         /* JS: We dont send NTFY or AUEP to wildcard ep */
2957                         if (strcmp(p->name, p->parent->wcardep) != 0) {
2958                                 transmit_notify_request(sub, "");
2959                 /* SC: Audit endpoint. 
2960                                  Idea is to prevent lost lines due to race conditions 
2961                                 */
2962                                 transmit_audit_endpoint(p);
2963                         }
2964                 }
2965         } else if (!strcasecmp(req->verb, "NTFY")) {
2966                 /* Acknowledge and be sure we keep looking for the same things */
2967                 transmit_response(sub, "200", req, "OK");
2968                 /* Notified of an event */
2969                 ev = get_header(req, "O");
2970                 s = strchr(ev, '/');
2971                 if (s) ev = s + 1;
2972         if (option_verbose > 2) {
2973             ast_verbose(VERBOSE_PREFIX_3 "Endpoint '%s@%s-%d' observed '%s'\n", p->name, p->parent->name, sub->id, ev);
2974         }
2975                 /* Keep looking for events unless this was a hangup */
2976                 if (strcasecmp(ev, "hu") && strcasecmp(ev, "hd") && strcasecmp(ev, "ping")) {
2977                         transmit_notify_request(sub, p->curtone);
2978         }
2979                 if (!strcasecmp(ev, "hd")) {
2980             p->hookstate = MGCP_OFFHOOK;
2981             sub->cxmode = MGCP_CX_SENDRECV;
2982             handle_hd_hf(sub, ev);
2983                 } else if (!strcasecmp(ev, "hf")) {
2984             /* We can assume we are offhook if we received a hookflash */
2985             /* First let's just do call wait and ignore threeway */
2986             /* We're currently in charge */
2987             if (p->hookstate != MGCP_OFFHOOK) {
2988                 /* Cisco c7940 sends hf even if the phone is onhook */
2989                 /* Thanks to point on IRC for pointing this out */
2990                 return -1;
2991             }
2992                     /* do not let * confrnce two down channels */  
2993                     if( sub->owner && sub->owner->_state == AST_STATE_DOWN && !sub->next->owner) return -1;
2994
2995             if (p->callwaiting || p->transfer || p->threewaycalling) {
2996                 if (option_verbose > 2) {
2997                     ast_verbose(VERBOSE_PREFIX_3 "Swapping %d for %d on %s@%s\n", p->sub->id, p->sub->next->id, p->name, p->parent->name);
2998                 }
2999                 p->sub = p->sub->next;
3000
3001                 /* transfer control to our next subchannel */
3002                 if (!sub->next->owner) {
3003                     /* plave the first call on hold and start up a new call */
3004                     sub->cxmode = MGCP_CX_MUTE;
3005                     if (option_verbose > 2) {
3006                         ast_verbose(VERBOSE_PREFIX_3 "MGCP Muting %d on %s@%s\n", sub->id, p->name, p->parent->name);
3007                     }
3008                     transmit_modify_request(sub);
3009                     if (sub->owner && ast_bridged_channel(sub->owner)) {
3010                         ast_moh_start(ast_bridged_channel(sub->owner), NULL);
3011                     }
3012                     sub->next->cxmode = MGCP_CX_RECVONLY;
3013                     handle_hd_hf(sub->next, ev);
3014                 } else if (sub->owner && sub->next->owner) {
3015                     /* We've got two active calls lets decide whether or not to conference or just flip flop */
3016                     if ((!sub->outgoing) && (!sub->next->outgoing)) {
3017                         /* We made both calls lets conferenct */
3018                         if (option_verbose > 2) {
3019                             ast_verbose(VERBOSE_PREFIX_3 "MGCP Conferencing %d and %d on %s@%s\n", 
3020                                         sub->id, sub->next->id, p->name, p->parent->name);
3021                         }
3022                         sub->cxmode = MGCP_CX_CONF;
3023                         sub->next->cxmode = MGCP_CX_CONF;
3024                         if (ast_bridged_channel(sub->next->owner)) 
3025                             ast_moh_stop(ast_bridged_channel(sub->next->owner));
3026                         transmit_modify_request(sub);
3027                         transmit_modify_request(sub->next);
3028                     } else {
3029                         /* Let's flipflop between calls */
3030                         /* XXX Need to check for state up ??? */
3031                         /* XXX Need a way to indicate the current call, or maybe the call that's waiting */
3032                         if (option_verbose > 2) {
3033                             ast_verbose(VERBOSE_PREFIX_3 "We didn't make one of the calls FLIPFLOP %d and %d on %s@%s\n", 
3034                                         sub->id, sub->next->id, p->name, p->parent->name);
3035                         }
3036                         sub->cxmode = MGCP_CX_MUTE;
3037                         if (option_verbose > 2) {
3038                             ast_verbose(VERBOSE_PREFIX_3 "MGCP Muting %d on %s@%s\n", sub->id, p->name, p->parent->name);
3039                         }
3040                         transmit_modify_request(sub);
3041                         if (ast_bridged_channel(sub->owner)) 
3042                             ast_moh_start(ast_bridged_channel(sub->owner), NULL);
3043                         
3044                         if (ast_bridged_channel(sub->next->owner)) 
3045                             ast_moh_stop(ast_bridged_channel(sub->next->owner));
3046                         
3047                         handle_hd_hf(sub->next, ev);
3048 #if 0
3049                         if (sub->next->owner && (sub->next->owner->_state != AST_STATE_UP)) {
3050                             handle_hd_hf(sub->next, ev);
3051                         } else {
3052                             ast_verbose(VERBOSE_PREFIX_3 "MGCP Unmuting %d on %s@%s\n", sub->next->id, p->name, p->parent->name);
3053                             sub->next->cxmode = MGCP_CX_SENDRECV;
3054                             transmit_modify_request(sub->next);
3055                         }
3056 #endif
3057                     }
3058                 } else {
3059                     /* We've most likely lost one of our calls find an active call and bring it up */
3060                     if (sub->owner) {
3061                         p->sub = sub;
3062                     } else if (sub->next->owner) {
3063                         p->sub = sub->next;
3064                     } else {
3065                         /* We seem to have lost both our calls */
3066                         /* XXX - What do we do now? */
3067                         return -1;
3068                     }
3069                     if (ast_bridged_channel(p->sub->owner)) {
3070                         ast_moh_stop(ast_bridged_channel(p->sub->owner));
3071                     }
3072                     p->sub->cxmode = MGCP_CX_SENDRECV;
3073                     transmit_modify_request(p->sub);
3074                 }
3075             } else {
3076                 ast_log(LOG_WARNING, "Callwaiting, call transfer or threeway calling not enabled on endpoint %s@%s\n", 
3077                         p->name, p->parent->name);
3078             }
3079             /* ast_moh_stop(sub->owner->bridge); */
3080                 } else if (!strcasecmp(ev, "hu")) {
3081             p->hookstate = MGCP_ONHOOK;
3082             sub->cxmode = MGCP_CX_RECVONLY;
3083             ast_log(LOG_DEBUG, "MGCP %s@%s Went on hook\n", p->name, p->parent->name);
3084             /* JS: Do we need to send MDCX before a DLCX ?
3085             if (sub->rtp) {
3086                 transmit_modify_request(sub);
3087             }
3088             */
3089             if (p->transfer && (sub->owner && sub->next->owner) && ((!sub->outgoing) || (!sub->next->outgoing))) {
3090                 /* We're allowed to transfer, we have two avtive calls and */
3091                 /* we made at least one of the calls.  Let's try and transfer */
3092                                 ast_mutex_lock(&p->sub->next->lock);
3093                                 res = attempt_transfer(p);
3094                 if (res < 0) {
3095                     if (p->sub->next->owner) {
3096                         sub->next->alreadygone = 1;
3097                         mgcp_queue_hangup(sub->next);
3098                     }
3099                 } else if (res) {
3100                     ast_log(LOG_WARNING, "Transfer attempt failed\n");
3101                                         ast_mutex_unlock(&p->sub->next->lock);
3102                     return -1;
3103                 }
3104                                 ast_mutex_unlock(&p->sub->next->lock);
3105             } else {
3106                 /* Hangup the current call */
3107                 /* If there is another active call, mgcp_hangup will ring the phone with the other call */
3108                 if (sub->owner) {
3109                     sub->alreadygone = 1;
3110                     mgcp_queue_hangup(sub);
3111                 } else {
3112                     /* SC: verbose level check */
3113                     if (option_verbose > 2) {
3114                                                 if (option_verbose > 2) {
3115                                                         ast_verbose(VERBOSE_PREFIX_3 "MGCP handle_request(%s@%s-%d) ast_channel already destroyed, resending DLCX.\n",
3116                                                                 p->name, p->parent->name, sub->id);
3117                                                 }
3118                                                 /* Instruct the other side to remove the connection since it apparently *
3119                                                  * still thinks the channel is active. *
3120                                                  * For Cisco IAD2421 /BAK/ */
3121                                                 transmit_connection_del(sub);
3122                     }
3123                 }
3124             }
3125             if ((p->hookstate == MGCP_ONHOOK) && (!sub->rtp) && (!sub->next->rtp)) {
3126                 if (has_voicemail(p)) {
3127                     if (option_verbose > 2) {
3128                         ast_verbose(VERBOSE_PREFIX_3 "MGCP handle_request(%s@%s) set vmwi(+)\n", p->name, p->parent->name);
3129                     }
3130                     transmit_notify_request(sub, "L/vmwi(+)");
3131                 } else {
3132                     if (option_verbose > 2) {
3133                         ast_verbose(VERBOSE_PREFIX_3 "MGCP handle_request(%s@%s) set vmwi(-)\n", p->name, p->parent->name);
3134                     }
3135                     transmit_notify_request(sub, "L/vmwi(-)");
3136                 }
3137             }
3138                 } else if ((strlen(ev) == 1) && 
3139                                         (((ev[0] >= '0') && (ev[0] <= '9')) ||
3140                                          ((ev[0] >= 'A') && (ev[0] <= 'D')) ||
3141                                          (ev[0] == '*') || (ev[0] == '#'))) {
3142                         f.frametype = AST_FRAME_DTMF;
3143                         f.subclass = ev[0];
3144                         f.src = "mgcp";
3145                         if (sub->owner) {
3146                 /* XXX MUST queue this frame to all subs in threeway call if threeway call is active */
3147                                 mgcp_queue_frame(sub, &f);
3148                                 ast_mutex_lock(&sub->next->lock);
3149                 if (sub->next->owner) {
3150                     mgcp_queue_frame(sub->next, &f);
3151                 }
3152                                 ast_mutex_unlock(&sub->next->lock);
3153             }
3154             if (strstr(p->curtone, "wt") && (ev[0] == 'A')) {
3155                 memset(p->curtone, 0, sizeof(p->curtone));
3156             }
3157                 }
3158         else if (!strcasecmp(ev, "T")) {
3159                         /* Digit timeout -- unimportant */
3160         }
3161         else if (!strcasecmp(ev, "ping")) {
3162                         /* ping -- unimportant */
3163                 } else {
3164                         ast_log(LOG_NOTICE, "Received unknown event '%s' from %s@%s\n", ev, p->name, p->parent->name);
3165                 }
3166         } else {
3167                 ast_log(LOG_WARNING, "Unknown verb '%s' received from %s\n", req->verb, ast_inet_ntoa(iabuf, sizeof(iabuf), sin->sin_addr));
3168                 transmit_response(sub, "510", req, "Unknown verb");
3169         }
3170         return 0;
3171 }
3172
3173 static int find_and_retrans(struct mgcp_subchannel *sub, struct mgcp_request *req)
3174 {
3175         int seqno=0;
3176         time_t now;
3177         struct mgcp_response *prev = NULL, *cur, *next, *answer=NULL;
3178         time(&now);
3179         if (sscanf(req->identifier, "%d", &seqno) != 1) 
3180                 seqno = 0;
3181         cur = sub->parent->parent->responses;
3182         while(cur) {
3183                 next = cur->next;
3184                 if (now - cur->whensent > RESPONSE_TIMEOUT) {
3185                         /* Delete this entry */
3186                         if (prev)
3187                                 prev->next = next;
3188                         else
3189                                 sub->parent->parent->responses = next;
3190                         free(cur);
3191                 } else {
3192                         if (seqno == cur->seqno)
3193                                 answer = cur;
3194                         prev = cur;
3195                 }
3196                 cur = next;
3197         }
3198         if (answer) {
3199                 resend_response(sub, answer);
3200                 return 1;
3201         }
3202         return 0;
3203 }
3204
3205 static int mgcpsock_read(int *id, int fd, short events, void *ignore)
3206 {
3207         struct mgcp_request req;
3208         struct sockaddr_in sin;
3209         struct mgcp_subchannel *sub;
3210         int res;
3211         int len;
3212         int result;
3213         int ident;
3214         char iabuf[INET_ADDRSTRLEN];
3215         len = sizeof(sin);
3216         memset(&req, 0, sizeof(req));
3217         res = recvfrom(mgcpsock, req.data, sizeof(req.data) - 1, 0, (struct sockaddr *)&sin, &len);
3218         if (res < 0) {
3219                 if (errno != ECONNREFUSED)
3220                         ast_log(LOG_WARNING, "Recv error: %s\n", strerror(errno));
3221                 return 1;
3222         }
3223         req.data[res] = '\0';
3224         req.len = res;
3225         if (mgcpdebug) {
3226                 ast_verbose("MGCP read: \n%s\nfrom %s:%d\n", req.data, ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port));
3227     }
3228         parse(&req);
3229         if (req.headers < 1) {
3230                 /* Must have at least one header */
3231                 return 1;
3232         }
3233         if (!req.identifier || !strlen(req.identifier)) {
3234                 ast_log(LOG_NOTICE, "Message from %s missing identifier\n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr));
3235                 return 1;
3236         }
3237
3238         if (sscanf(req.verb, "%d", &result) &&
3239                 sscanf(req.identifier, "%d", &ident)) {
3240                 /* Try to find who this message is for, if it's important */
3241                 sub = find_subchannel_and_lock(NULL, ident, &sin);
3242                 if (sub) {
3243             struct mgcp_gateway *gw = sub->parent->parent;
3244             struct mgcp_message *cur, *prev;
3245
3246                         ast_mutex_unlock(&sub->lock);
3247             ast_mutex_lock(&gw->msgs_lock);
3248             for (prev = NULL, cur = gw->msgs; cur; prev = cur, cur = cur->next) {
3249                 if (cur->seqno == ident) {
3250                     ast_log(LOG_DEBUG, "Got response back on transaction %d\n", ident);
3251                     if (prev)
3252                         prev->next = cur->next;
3253                     else 
3254                         gw->msgs = cur->next;
3255                     break;
3256                 }
3257             }
3258
3259             /* stop retrans timer if the queue is empty */
3260             if (!gw->msgs && (gw->retransid != -1)) {
3261                 ast_sched_del(sched, gw->retransid);
3262                 gw->retransid = -1;
3263             }
3264
3265             ast_mutex_unlock(&gw->msgs_lock);
3266             if (cur) {
3267                 handle_response(cur->owner_ep, cur->owner_sub, result, ident, &req);
3268                 free(cur);
3269                 return 1;
3270             }
3271
3272             ast_log(LOG_NOTICE, "Got response back on [%s] for transaction %d we aren't sending?\n", 
3273                     gw->name, ident);
3274                 }
3275         } else {
3276                 if (!req.endpoint || !strlen(req.endpoint) || 
3277                     !req.version || !strlen(req.version) || 
3278                         !req.verb || !strlen(req.verb)) {
3279                         ast_log(LOG_NOTICE, "Message must have a verb, an idenitifier, version, and endpoint\n");
3280                         return 1;
3281                 }
3282                 /* Process request, with iflock held */
3283                 sub = find_subchannel_and_lock(req.endpoint, 0, &sin);
3284                 if (sub) {
3285                         /* look first to find a matching response in the queue */
3286                         if (!find_and_retrans(sub, &req))
3287                     /* pass the request off to the currently mastering subchannel */
3288                                 handle_request(sub, &req, &sin);
3289                         ast_mutex_unlock(&sub->lock);
3290                 }
3291         }
3292         return 1;
3293 }
3294
3295 static int *mgcpsock_read_id = NULL;
3296
3297 static void *do_monitor(void *data)
3298 {
3299         int res;
3300         int reloading;
3301     /* struct mgcp_gateway *g; */
3302     /* struct mgcp_endpoint *e; */
3303         /*time_t thispass = 0, lastpass = 0;*/
3304
3305         /* Add an I/O event to our UDP socket */
3306         if (mgcpsock > -1) 
3307                 mgcpsock_read_id = ast_io_add(io, mgcpsock, mgcpsock_read, AST_IO_IN, NULL);
3308         
3309         /* This thread monitors all the frame relay interfaces which are not yet in use
3310            (and thus do not have a separate thread) indefinitely */
3311         /* From here on out, we die whenever asked */
3312         for(;;) {
3313         /* Check for a reload request */
3314                 ast_mutex_lock(&mgcp_reload_lock);
3315                 reloading = mgcp_reloading;
3316                 mgcp_reloading = 0;
3317                 ast_mutex_unlock(&mgcp_reload_lock);
3318                 if (reloading) {
3319                         if (option_verbose > 0)
3320                                 ast_verbose(VERBOSE_PREFIX_1 "Reloading MGCP\n");
3321                         mgcp_do_reload();
3322                         /* Add an I/O event to our UDP socket */
3323                         if (mgcpsock > -1) 
3324                                 mgcpsock_read_id = ast_io_add(io, mgcpsock, mgcpsock_read, AST_IO_IN, NULL);
3325                 }
3326
3327         /* Check for interfaces needing to be killed */
3328                 /* Don't let anybody kill us right away.  Nobody should lock the interface list
3329                    and wait for the monitor list, but the other way around is okay. */
3330                 ast_mutex_lock(&monlock);
3331                 /* Lock the network interface */
3332                 ast_mutex_lock(&netlock);
3333
3334         /* XXX THIS IS COMPLETELY HOSED */
3335         /* The gateway goes into a state of panic */
3336         /* If the vmwi indicator is sent while it is reseting interfaces */
3337 #if 0
3338         lastpass = thispass;
3339         thispass = time(NULL);
3340         g = gateways;
3341         while(g) {
3342             if (thispass != lastpass) {
3343                 e = g->endpoints;
3344                 while(e) {
3345                     if (e->type == TYPE_LINE) {
3346                         res = has_voicemail(e);
3347                         if ((e->msgstate != res) && (e->hookstate == MGCP_ONHOOK) && (!e->rtp)){
3348                             if (res) {
3349                                 transmit_notify_request(e, "L/vmwi(+)");
3350                             } else {
3351                                 transmit_notify_request(e, "L/vmwi(-)");
3352                             }
3353                             e->msgstate = res;
3354                             e->onhooktime = thispass;
3355                         }
3356                     }
3357                     e = e->next;
3358                 }
3359             }
3360             g = g->next;
3361         }
3362 #endif
3363         
3364                 /* Okay, now that we know what to do, release the network lock */
3365                 ast_mutex_unlock(&netlock);
3366                 /* And from now on, we're okay to be killed, so release the monitor lock as well */
3367                 ast_mutex_unlock(&monlock);
3368                 pthread_testcancel();
3369                 /* Wait for sched or io */
3370                 res = ast_sched_wait(sched);
3371         /* SC: copied from chan_sip.c */
3372                 if ((res < 0) || (res > 1000))
3373                         res = 1000;
3374                 res = ast_io_wait(io, res);
3375                 ast_mutex_lock(&monlock);
3376                 if (res >= 0) 
3377                         ast_sched_runq(sched);
3378                 ast_mutex_unlock(&monlock);
3379         }
3380         /* Never reached */
3381         return NULL;
3382         
3383 }
3384
3385 static int restart_monitor(void)
3386 {
3387         pthread_attr_t attr;
3388         pthread_attr_init(&attr);
3389         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);    
3390
3391         /* If we're supposed to be stopped -- stay stopped */
3392         if (monitor_thread == AST_PTHREADT_STOP)
3393                 return 0;
3394         if (ast_mutex_lock(&monlock)) {
3395                 ast_log(LOG_WARNING, "Unable to lock monitor\n");
3396                 return -1;
3397         }
3398         if (monitor_thread == pthread_self()) {
3399                 ast_mutex_unlock(&monlock);
3400                 ast_log(LOG_WARNING, "Cannot kill myself\n");
3401                 return -1;
3402         }
3403         if (monitor_thread != AST_PTHREADT_NULL) {
3404                 /* Wake up the thread */
3405                 pthread_kill(monitor_thread, SIGURG);
3406         } else {
3407                 /* Start a new monitor */
3408                 if (ast_pthread_create(&monitor_thread, &attr, do_monitor, NULL) < 0) {
3409                         ast_mutex_unlock(&monlock);
3410                         ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
3411                         return -1;
3412                 }
3413         }
3414         ast_mutex_unlock(&monlock);
3415         return 0;
3416 }
3417
3418 static struct ast_channel *mgcp_request(const char *type, int format, void *data, int *cause)
3419 {
3420         int oldformat;
3421         struct mgcp_subchannel *sub;
3422         struct ast_channel *tmpc = NULL;
3423         char tmp[256];
3424         char *dest = data;
3425
3426         oldformat = format;
3427         format &= capability;
3428         if (!format) {
3429                 ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format '%d'\n", format);
3430                 return NULL;
3431         }
3432         strncpy(tmp, dest, sizeof(tmp) - 1);
3433         if (!strlen(tmp)) {
3434                 ast_log(LOG_NOTICE, "MGCP Channels require an endpoint\n");
3435                 return NULL;
3436         }
3437         sub = find_subchannel_and_lock(tmp, 0, NULL);
3438         if (!sub) {
3439                 ast_log(LOG_WARNING, "Unable to find MGCP endpoint '%s'\n", tmp);
3440                 *cause = AST_CAUSE_UNREGISTERED;
3441                 return NULL;
3442         }
3443         
3444     if (option_verbose > 2) {
3445         ast_verbose(VERBOSE_PREFIX_3 "MGCP mgcp_request(%s)\n", tmp);
3446         ast_verbose(VERBOSE_PREFIX_3 "MGCP cw: %d, dnd: %d, so: %d, sno: %d\n", 
3447                     sub->parent->callwaiting, sub->parent->dnd, sub->owner ? 1 : 0, sub->next->owner ? 1: 0);
3448     }
3449         /* Must be busy */
3450         if (((sub->parent->callwaiting) && ((sub->owner) && (sub->next->owner))) ||
3451         ((!sub->parent->callwaiting) && (sub->owner)) ||
3452          (sub->parent->dnd && (!strlen(sub->parent->call_forward)))) {
3453          if (sub->parent->hookstate == MGCP_ONHOOK) {
3454              if (has_voicemail(sub->parent)) {
3455                  transmit_notify_request(sub,"L/vmwi(+)");
3456              } else {
3457                  transmit_notify_request(sub,"L/vmwi(-)");
3458              }
3459          }
3460                 *cause = AST_CAUSE_BUSY;
3461                 ast_mutex_unlock(&sub->lock);
3462                 return NULL;
3463     }
3464         tmpc = mgcp_new(sub->owner ? sub->next : sub, AST_STATE_DOWN);
3465         ast_mutex_unlock(&sub->lock);
3466         if (!tmpc)
3467                 ast_log(LOG_WARNING, "Unable to make channel for '%s'\n", tmp);
3468         restart_monitor();
3469         return tmpc;
3470 }
3471
3472 /* SC: modified for reload support */
3473 static struct mgcp_gateway *build_gateway(char *cat, struct ast_variable *v)
3474 {
3475         struct mgcp_gateway *gw;
3476         struct mgcp_endpoint *e;
3477     struct mgcp_subchannel *sub;
3478     /*char txident[80];*/
3479     int i=0, y=0;
3480     int gw_reload = 0;
3481     int ep_reload = 0;
3482         canreinvite = CANREINVITE;
3483
3484     /* SC: locate existing gateway */
3485     gw = gateways;
3486     while (gw) {
3487         if (!strcasecmp(cat, gw->name)) {
3488             /* gateway already exists */
3489             gw->delme = 0;
3490             gw_reload = 1;
3491             break;
3492         }
3493         gw = gw->next;
3494     }
3495
3496     if (!gw)
3497         gw = malloc(sizeof(struct mgcp_gateway));
3498
3499         if (gw) {
3500         if (!gw_reload) {
3501             memset(gw, 0, sizeof(struct mgcp_gateway));
3502             gw->expire = -1;
3503             gw->retransid = -1; /* SC */
3504             ast_mutex_init(&gw->msgs_lock);
3505             strncpy(gw->name, cat, sizeof(gw->name) - 1);
3506             /* SC: check if the name is numeric ip */
3507             if ((strchr(gw->name, '.')) && inet_addr(gw->name) != INADDR_NONE)
3508                 gw->isnamedottedip = 1;
3509         }
3510                 while(v) {
3511                         if (!strcasecmp(v->name, "host")) {
3512                                 if (!strcasecmp(v->value, "dynamic")) {
3513                                         /* They'll register with us */
3514                                         gw->dynamic = 1;
3515                                         memset(&gw->addr.sin_addr, 0, 4);
3516                                         if (gw->addr.sin_port) {
3517                                                 /* If we've already got a port, make it the default rather than absolute */
3518                                                 gw->defaddr.sin_port = gw->addr.sin_port;
3519                                                 gw->addr.sin_port = 0;
3520                                         }
3521                                 } else {
3522                                         /* Non-dynamic.  Make sure we become that way if we're not */
3523                                         if (gw->expire > -1)
3524                                                 ast_sched_del(sched, gw->expire);
3525                                         gw->expire = -1;
3526                                         gw->dynamic = 0;
3527                                         if (ast_get_ip(&gw->addr, v->value)) {
3528                         if (!gw_reload) {
3529                             ast_mutex_destroy(&gw->msgs_lock);
3530                             free(gw);
3531                                                 }
3532                                                 return NULL;
3533                                         }
3534                                 }
3535                         } else if (!strcasecmp(v->name, "defaultip")) {
3536                                 if (ast_get_ip(&gw->defaddr, v->value)) {
3537                     if (!gw_reload) {
3538                         ast_mutex_destroy(&gw->msgs_lock);
3539                         free(gw);
3540                     }
3541                                         return NULL;
3542                                 }
3543                         } else if (!strcasecmp(v->name, "permit") ||
3544                                            !strcasecmp(v->name, "deny")) {
3545                                 gw->ha = ast_append_ha(v->name, v->value, gw->ha);
3546                         } else if (!strcasecmp(v->name, "port")) {
3547                                 gw->addr.sin_port = htons(atoi(v->value));
3548                         } else if (!strcasecmp(v->name, "context")) {
3549                                 strncpy(context, v->value, sizeof(context) - 1);
3550                         } else if (!strcasecmp(v->name, "dtmfmode")) {
3551                                 if (!strcasecmp(v->value, "inband"))
3552                                         dtmfmode = MGCP_DTMF_INBAND;
3553                                 else if (!strcasecmp(v->value, "rfc2833")) 
3554                                         dtmfmode = MGCP_DTMF_RFC2833;
3555                                 else if (!strcasecmp(v->value, "none")) 
3556                                         dtmfmode = 0;
3557                                 else
3558                                         ast_log(LOG_WARNING, "'%s' is not a valid DTMF mode at line %d\n", v->value, v->lineno);
3559                         } else if (!strcasecmp(v->name, "nat")) {
3560                                 nat = ast_true(v->value);
3561                         } else if (!strcasecmp(v->name, "callerid")) {
3562                                 if (!strcasecmp(v->value, "asreceived")) {
3563                                         cid_num[0] = '\0';
3564                                         cid_name[0] = '\0';
3565                                 } else {
3566                                         ast_callerid_split(v->value, cid_name, sizeof(cid_name), cid_num, sizeof(cid_num));
3567                                 }
3568                         } else if (!strcasecmp(v->name, "language")) {
3569                                 strncpy(language, v->value, sizeof(language)-1);
3570             } else if (!strcasecmp(v->name, "accountcode")) {
3571                 strncpy(accountcode, v->value, sizeof(accountcode)-1);
3572             } else if (!strcasecmp(v->name, "amaflags")) {
3573                 y = ast_cdr_amaflags2int(v->value);
3574                 if (y < 0) {
3575                     ast_log(LOG_WARNING, "Invalid AMA flags: %s at line %d\n", v->value, v->lineno);
3576                 } else {
3577                     amaflags = y;
3578                 }
3579             } else if (!strcasecmp(v->name, "musiconhold")) {
3580                 strncpy(musicclass, v->value, sizeof(musicclass)-1);
3581             } else if (!strcasecmp(v->name, "callgroup")) {
3582                 cur_callergroup = ast_get_group(v->value);
3583             } else if (!strcasecmp(v->name, "pickupgroup")) {
3584                 cur_pickupgroup = ast_get_group(v->value);
3585             } else if (!strcasecmp(v->name, "immediate")) {
3586                 immediate = ast_true(v->value);
3587             } else if (!strcasecmp(v->name, "cancallforward")) {
3588                 cancallforward = ast_true(v->value);
3589             } else if (!strcasecmp(v->name, "singlepath")) {
3590                 singlepath = ast_true(v->value);
3591             } else if (!strcasecmp(v->name, "canreinvite")) {
3592            &nb