AST_CONTROL_CONNECTED_LINE frame type processing added to setup DisplayIE field
[asterisk/asterisk.git] / addons / ooh323c / src / ooStackCmds.c
1 /*
2  * Copyright (C) 2004-2005 by Objective Systems, Inc.
3  *
4  * This software is furnished under an open source license and may be 
5  * used and copied only in accordance with the terms of this license. 
6  * The text of the license may generally be found in the root 
7  * directory of this installation in the COPYING file.  It 
8  * can also be viewed online at the following URL:
9  *
10  *   http://www.obj-sys.com/open/license.html
11  *
12  * Any redistributions of this file including modified versions must 
13  * maintain this copyright notice.
14  *
15  *****************************************************************************/
16 #include <asterisk.h>
17 #include <asterisk/lock.h>
18
19 #include "ooStackCmds.h"
20 #include "ooh323ep.h"
21 #include "ooCalls.h"
22 #include "ooCmdChannel.h"
23
24 extern OOSOCKET gCmdChan;
25 extern ast_mutex_t newCallLock;
26
27 static int counter = 1;
28
29 int ooGenerateOutgoingCallToken (char *callToken, size_t size)
30 {
31    char aCallToken[200];
32    int  ret = 0;
33
34    ast_mutex_lock(&newCallLock);
35    sprintf (aCallToken, "ooh323c_o_%d", counter++);
36
37    if (counter > OO_MAX_CALL_TOKEN)
38       counter = 1;
39    ast_mutex_unlock(&newCallLock);
40
41    if ((strlen(aCallToken)+1) < size)
42       strcpy (callToken, aCallToken);
43    else {
44       ret = OO_FAILED;
45    }
46
47    return ret;
48 }
49
50 int isRunning(char *callToken) {
51   OOH323CallData *call;
52
53   if((call = ooFindCallByToken(callToken)))
54    if (call->Monitor)
55     return 1;
56   return 0;
57 }
58
59 OOStkCmdStat ooMakeCall 
60    (const char* dest, char* callToken, size_t bufsiz, ooCallOptions *opts)
61 {
62    OOStackCommand cmd;
63
64    if(!callToken)
65       return OO_STKCMD_INVALIDPARAM;
66   
67
68    /* Generate call token*/
69    if (ooGenerateOutgoingCallToken (callToken, bufsiz) != OO_OK){
70       return OO_STKCMD_INVALIDPARAM;
71    }
72
73    if(gCmdChan == 0)
74    {
75       if(ooCreateCmdConnection() != OO_OK)
76          return OO_STKCMD_CONNECTIONERR;
77    }
78
79    memset(&cmd, 0, sizeof(OOStackCommand));
80    cmd.type = OO_CMD_MAKECALL;
81    cmd.param1 = (void*) malloc(strlen(dest)+1);
82    if(!cmd.param1)
83    {
84       return OO_STKCMD_MEMERR;
85    }
86    strcpy((char*)cmd.param1, dest);
87
88   
89    cmd.param2 = (void*) malloc(strlen(callToken)+1);
90    if(!cmd.param2)
91    {
92       free(cmd.param1);
93       return OO_STKCMD_MEMERR;
94    }
95    
96    strcpy((char*)cmd.param2, callToken);
97
98    if(!opts)
99    {
100       cmd.param3 = 0;
101    }
102    else {
103       cmd.param3 = (void*) malloc(sizeof(ooCallOptions));
104       if(!cmd.param3)
105       {
106          free(cmd.param1);
107          free(cmd.param2);
108          return OO_STKCMD_MEMERR;
109       }
110       memcpy((void*)cmd.param3, opts, sizeof(ooCallOptions));
111    }
112
113    if(ooWriteStackCommand(&cmd) != OO_OK)
114    {
115       free(cmd.param1);
116       free(cmd.param2);
117       if(cmd.param3) free(cmd.param3);
118       return OO_STKCMD_WRITEERR;
119    }
120
121    return OO_STKCMD_SUCCESS;
122 }
123
124 OOStkCmdStat ooRunCall 
125    (const char* dest, char* callToken, size_t bufsiz, ooCallOptions *opts)
126 {
127    OOStackCommand cmd;
128    OOH323CallData *call;
129
130    if(!callToken)
131    {
132       return OO_STKCMD_INVALIDPARAM;
133    }
134
135    if(!(call = ooFindCallByToken(callToken))) {
136       return OO_STKCMD_INVALIDPARAM;
137    }
138
139    if(call->CmdChan == 0)
140    {
141       if(ooCreateCallCmdConnection(call) != OO_OK)
142          return OO_STKCMD_CONNECTIONERR;
143    }
144
145    if(!callToken)
146       return OO_STKCMD_INVALIDPARAM;
147   
148
149    memset(&cmd, 0, sizeof(OOStackCommand));
150    cmd.type = OO_CMD_MAKECALL;
151    cmd.param1 = (void*) malloc(strlen(dest)+1);
152    if(!cmd.param1)
153    {
154       return OO_STKCMD_MEMERR;
155    }
156    strcpy((char*)cmd.param1, dest);
157    cmd.plen1 = strlen(dest);
158
159   
160    cmd.param2 = (void*) malloc(strlen(callToken)+1);
161    if(!cmd.param2)
162    {
163       free(cmd.param1);
164       return OO_STKCMD_MEMERR;
165    }
166    
167    strcpy((char*)cmd.param2, callToken);
168    cmd.plen2 = strlen(callToken);
169
170    if(!opts)
171    {
172       cmd.param3 = 0;
173    }
174    else {
175       cmd.param3 = (void*) malloc(sizeof(ooCallOptions));
176       if(!cmd.param3)
177       {
178          free(cmd.param1);
179          free(cmd.param2);
180          return OO_STKCMD_MEMERR;
181       }
182       memcpy((void*)cmd.param3, opts, sizeof(ooCallOptions));
183       cmd.plen3 = sizeof(ooCallOptions);
184    }
185
186    if(ooWriteCallStackCommand(call, &cmd) != OO_OK)
187    {
188       free(cmd.param1);
189       free(cmd.param2);
190       if(cmd.param3) free(cmd.param3);
191       return OO_STKCMD_WRITEERR;
192    }
193
194
195    free(cmd.param1);
196    free(cmd.param2);
197    if(cmd.param3) free(cmd.param3);
198
199    return OO_STKCMD_SUCCESS;
200 }
201
202
203 OOStkCmdStat ooManualRingback(const char *callToken)
204 {
205    OOStackCommand cmd;
206    OOH323CallData *call;
207
208    if(!callToken)
209    {
210       return OO_STKCMD_INVALIDPARAM;
211    }
212
213    if(!(call = ooFindCallByToken(callToken))) {
214       return OO_STKCMD_INVALIDPARAM;
215    }
216
217    if(call->CmdChan == 0)
218    {
219       if(ooCreateCallCmdConnection(call) != OO_OK)
220          return OO_STKCMD_CONNECTIONERR;
221    }
222
223    memset(&cmd, 0, sizeof(OOStackCommand));
224    cmd.type = OO_CMD_MANUALRINGBACK;
225    cmd.param1 = (void*) malloc(strlen(callToken)+1);
226    if(!cmd.param1)
227    {
228       return OO_STKCMD_MEMERR;
229    }
230    strcpy((char*)cmd.param1, callToken);
231    cmd.plen1 = strlen(callToken);
232    
233    if(ooWriteCallStackCommand(call,&cmd) != OO_OK)
234    {
235       free(cmd.param1);
236       return OO_STKCMD_WRITEERR;
237    }
238
239    free(cmd.param1);
240
241    return OO_STKCMD_SUCCESS;
242 }
243
244 OOStkCmdStat ooManualProgress(const char *callToken)
245 {
246    OOStackCommand cmd;
247    OOH323CallData *call;
248
249    if(!callToken)
250    {
251       return OO_STKCMD_INVALIDPARAM;
252    }
253
254    if(!(call = ooFindCallByToken(callToken))) {
255       return OO_STKCMD_INVALIDPARAM;
256    }
257
258    if(call->CmdChan == 0)
259    {
260       if(ooCreateCallCmdConnection(call) != OO_OK)
261          return OO_STKCMD_CONNECTIONERR;
262    }
263
264    memset(&cmd, 0, sizeof(OOStackCommand));
265    cmd.type = OO_CMD_MANUALPROGRESS;
266    cmd.param1 = (void*) malloc(strlen(callToken)+1);
267    if(!cmd.param1)
268    {
269       return OO_STKCMD_MEMERR;
270    }
271    strcpy((char*)cmd.param1, callToken);
272    cmd.plen1 = strlen(callToken);
273    
274    if(ooWriteCallStackCommand(call, &cmd) != OO_OK)
275    {
276       free(cmd.param1);
277       return OO_STKCMD_WRITEERR;
278    }
279
280    free(cmd.param1);
281
282    return OO_STKCMD_SUCCESS;
283 }
284
285 OOStkCmdStat ooAnswerCall(const char *callToken)
286 {
287    OOStackCommand cmd;
288    OOH323CallData *call;
289
290    if(!callToken)
291    {
292       return OO_STKCMD_INVALIDPARAM;
293    }
294
295    if(!(call = ooFindCallByToken(callToken))) {
296       return OO_STKCMD_INVALIDPARAM;
297    }
298
299    if(call->CmdChan == 0)
300    {
301       if(ooCreateCallCmdConnection(call) != OO_OK)
302          return OO_STKCMD_CONNECTIONERR;
303    }
304
305    memset(&cmd, 0, sizeof(OOStackCommand));
306    cmd.type = OO_CMD_ANSCALL;
307
308    cmd.param1 = (void*) malloc(strlen(callToken)+1);
309    if(!cmd.param1)
310    {
311       return OO_STKCMD_MEMERR;
312    }
313    strcpy((char*)cmd.param1, callToken);
314    cmd.plen1 = strlen(callToken);   
315
316    if(ooWriteCallStackCommand(call, &cmd) != OO_OK)
317    {
318       free(cmd.param1);
319       return OO_STKCMD_WRITEERR;
320    }
321
322    free(cmd.param1);
323
324    return OO_STKCMD_SUCCESS;
325 }
326
327 OOStkCmdStat ooForwardCall(const char* callToken, char *dest)
328 {
329    OOStackCommand cmd;
330    OOH323CallData *call;
331
332    if(!callToken || !dest)
333    {
334       return OO_STKCMD_INVALIDPARAM;
335    }
336
337    if(!(call = ooFindCallByToken(callToken))) {
338       return OO_STKCMD_INVALIDPARAM;
339    }
340
341    if(call->CmdChan == 0)
342    {
343       if(ooCreateCallCmdConnection(call) != OO_OK)
344          return OO_STKCMD_CONNECTIONERR;
345    }
346    memset(&cmd, 0, sizeof(OOStackCommand));
347    cmd.type = OO_CMD_FWDCALL;
348
349    cmd.param1 = (void*) malloc(strlen(callToken)+1);
350    cmd.param2 = (void*) malloc(strlen(dest)+1);
351    if(!cmd.param1 || !cmd.param2)
352    {
353       if(cmd.param1)   free(cmd.param1);  /* Release memory */
354       if(cmd.param2)   free(cmd.param2);
355       return OO_STKCMD_MEMERR;
356    }
357    strcpy((char*)cmd.param1, callToken);
358    cmd.plen1 = strlen(callToken);
359    strcpy((char*)cmd.param2, dest);
360    cmd.plen2 = strlen(dest);
361
362    if(ooWriteCallStackCommand(call, &cmd) != OO_OK)
363    {
364       free(cmd.param1);
365       free(cmd.param2);
366       return OO_STKCMD_WRITEERR;
367    }
368    free(cmd.param1);
369    free(cmd.param2);
370
371    return OO_STKCMD_SUCCESS;
372 }
373
374
375 OOStkCmdStat ooHangCall(const char* callToken, OOCallClearReason reason, int q931cause)
376 {
377    OOStackCommand cmd;
378
379    OOH323CallData *call;
380
381    if(!callToken)
382    {
383       return OO_STKCMD_INVALIDPARAM;
384    }
385
386    if(!(call = ooFindCallByToken(callToken))) {
387       return OO_STKCMD_INVALIDPARAM;
388    }
389
390    if(call->CmdChan == 0)
391    {
392       if(ooCreateCallCmdConnection(call) != OO_OK)
393          return OO_STKCMD_CONNECTIONERR;
394    }
395
396    memset(&cmd, 0, sizeof(OOStackCommand));
397    cmd.type = OO_CMD_HANGCALL;
398    cmd.param1 = (void*) malloc(strlen(callToken)+1);
399    cmd.param2 = (void*) malloc(sizeof(OOCallClearReason));
400    cmd.param3 = (void*) malloc(sizeof(int));
401    if(!cmd.param1 || !cmd.param2 || !cmd.param3)
402    {
403       if(cmd.param1)   free(cmd.param1); /* Release memory */
404       if(cmd.param2)   free(cmd.param2);
405       if(cmd.param3)   free(cmd.param3);
406       return OO_STKCMD_MEMERR;
407    }
408    strcpy((char*)cmd.param1, callToken);
409    cmd.plen1 = strlen(callToken);
410    *((OOCallClearReason*)cmd.param2) = reason;
411    cmd.plen2 = sizeof(OOCallClearReason);
412    *(int *)cmd.param3 = q931cause;
413    cmd.plen3 = sizeof(int);
414
415    if(ooWriteCallStackCommand(call, &cmd) != OO_OK)
416    {
417       free(cmd.param1);
418       free(cmd.param2);
419       free(cmd.param3);
420       return OO_STKCMD_WRITEERR;
421    }
422    free(cmd.param1);
423    free(cmd.param2);
424    free(cmd.param3);
425    
426    return OO_STKCMD_SUCCESS;
427 }
428
429
430 OOStkCmdStat ooStopMonitor()
431 {
432    OOStackCommand cmd;
433
434    if(gCmdChan == 0)
435    {
436       if(ooCreateCmdConnection() != OO_OK)
437          return OO_STKCMD_CONNECTIONERR;
438    }
439
440    memset(&cmd, 0, sizeof(OOStackCommand));
441    cmd.type = OO_CMD_STOPMONITOR;
442    
443    if(ooWriteStackCommand(&cmd) != OO_OK)
444       return OO_STKCMD_WRITEERR;
445
446    return OO_STKCMD_SUCCESS;
447 }
448
449 OOStkCmdStat ooSendDTMFDigit(const char *callToken, const char* dtmf)
450 {
451    OOStackCommand cmd;
452    OOH323CallData *call;
453
454    if(!callToken)
455    {
456       return OO_STKCMD_INVALIDPARAM;
457    }
458
459    if(!(call = ooFindCallByToken(callToken))) {
460       return OO_STKCMD_INVALIDPARAM;
461    }
462
463    if(call->CmdChan == 0)
464    {
465       if(ooCreateCallCmdConnection(call) != OO_OK)
466          return OO_STKCMD_CONNECTIONERR;
467    }
468
469    memset(&cmd, 0, sizeof(OOStackCommand));
470    cmd.type = OO_CMD_SENDDIGIT;
471
472    cmd.param1 = (void*) malloc(strlen(callToken)+1);
473    cmd.param2 = (void*) malloc(strlen(dtmf)+1);
474    if(!cmd.param1 || !cmd.param2)
475    {
476       if(cmd.param1)   free(cmd.param1); /* Release memory */
477       if(cmd.param2)   free(cmd.param2);
478       return OO_STKCMD_MEMERR;
479    }
480    strcpy((char*)cmd.param1, callToken);
481    cmd.plen1 = strlen(callToken);
482    strcpy((char*)cmd.param2, dtmf);
483    cmd.plen2 = strlen(dtmf);
484    
485    if(ooWriteCallStackCommand(call,&cmd) != OO_OK)
486    {
487       free(cmd.param1);
488       free(cmd.param2);
489       return OO_STKCMD_WRITEERR;
490    }
491    free(cmd.param1);
492    free(cmd.param2);
493
494    return OO_STKCMD_SUCCESS;
495 }
496
497 OOStkCmdStat ooSetANI(const char *callToken, const char* ani)
498 {
499    OOStackCommand cmd;
500    OOH323CallData *call;
501
502    if(!callToken)
503    {
504       return OO_STKCMD_INVALIDPARAM;
505    }
506
507    if(!(call = ooFindCallByToken(callToken))) {
508       return OO_STKCMD_INVALIDPARAM;
509    }
510
511    if(call->CmdChan == 0)
512    {
513       if(ooCreateCallCmdConnection(call) != OO_OK)
514          return OO_STKCMD_CONNECTIONERR;
515    }
516
517    memset(&cmd, 0, sizeof(OOStackCommand));
518    cmd.type = OO_CMD_SETANI;
519
520    cmd.param1 = (void*) malloc(strlen(callToken)+1);
521    cmd.param2 = (void*) malloc(strlen(ani)+1);
522    if(!cmd.param1 || !cmd.param2)
523    {
524       if(cmd.param1)   free(cmd.param1); /* Release memory */
525       if(cmd.param2)   free(cmd.param2);
526       return OO_STKCMD_MEMERR;
527    }
528    strcpy((char*)cmd.param1, callToken);
529    cmd.plen1 = strlen(callToken);
530    strcpy((char*)cmd.param2, ani);
531    cmd.plen2 = strlen(ani);
532    
533    if(ooWriteCallStackCommand(call,&cmd) != OO_OK)
534    {
535       free(cmd.param1);
536       free(cmd.param2);
537       return OO_STKCMD_WRITEERR;
538    }
539    free(cmd.param1);
540    free(cmd.param2);
541
542    return OO_STKCMD_SUCCESS;
543 }
544
545 OOStkCmdStat ooRequestChangeMode(const char *callToken, int isT38Mode)
546 {
547    OOStackCommand cmd;
548    OOH323CallData *call;
549
550    if(!callToken)
551    {
552       return OO_STKCMD_INVALIDPARAM;
553    }
554
555    if(!(call = ooFindCallByToken(callToken))) {
556       return OO_STKCMD_INVALIDPARAM;
557    }
558
559    if(call->CmdChan == 0)
560    {
561       if(ooCreateCallCmdConnection(call) != OO_OK)
562          return OO_STKCMD_CONNECTIONERR;
563    }
564
565    memset(&cmd, 0, sizeof(OOStackCommand));
566    cmd.type = OO_CMD_REQMODE;
567
568    cmd.param1 = (void*) malloc(strlen(callToken)+1);
569    cmd.param2 = (void*) malloc(sizeof(int));
570    if(!cmd.param1 || !cmd.param2)
571    {
572       if(cmd.param1)   free(cmd.param1); /* Release memory */
573       if(cmd.param2)   free(cmd.param2);
574       return OO_STKCMD_MEMERR;
575    }
576    strcpy((char*)cmd.param1, callToken);
577    cmd.plen1 = strlen(callToken);
578    *((int *) cmd.param2) = isT38Mode;
579    cmd.plen2 = sizeof(int);
580    
581    if(ooWriteCallStackCommand(call,&cmd) != OO_OK)
582    {
583       free(cmd.param1);
584       free(cmd.param2);
585       return OO_STKCMD_WRITEERR;
586    }
587    free(cmd.param1);
588    free(cmd.param2);
589
590    return OO_STKCMD_SUCCESS;
591 }
592
593
594 const char* ooGetStkCmdStatusCodeTxt(OOStkCmdStat stat)
595 {
596    switch(stat)
597    {
598       case OO_STKCMD_SUCCESS:
599          return "Stack command - successfully issued";
600
601       case OO_STKCMD_MEMERR:
602          return "Stack command - Memory allocation error";
603
604       case OO_STKCMD_INVALIDPARAM:
605          return "Stack command - Invalid parameter";
606
607       case OO_STKCMD_WRITEERR:
608          return "Stack command - write error";
609
610       case OO_STKCMD_CONNECTIONERR: 
611          return "Stack command - Failed to create command channel";
612
613       default:
614          return "Invalid status code";
615    }
616 }
617