phase 1 of header include cleanup (bug #4067)
[asterisk/asterisk.git] / muted.c
1 /*
2  * Mute Daemon
3  *
4  * Specially written for Malcolm Davenport, but I think I'll use it too
5  *
6  * Copyright (C)  2004 - 2005, Digium Inc.
7  *
8  * Mark Spencer <markster@digium.com>
9  *
10  * Distributed under the terms of the GNU General Public License version 2.0 
11  *
12  */
13
14 #include <linux/soundcard.h>
15 #include <stdio.h>
16 #include <errno.h>
17 #include <stdlib.h>
18 #include <unistd.h>
19 #include <fcntl.h>
20 #include <string.h>
21 #include <netdb.h>
22 #include <sys/socket.h>
23 #include <sys/ioctl.h>
24 #include <netinet/in.h>
25 #include <arpa/inet.h>
26
27 static char *config = "/etc/muted.conf";
28
29 static char host[256] = "";
30 static char user[256] = "";
31 static char pass[256] = "";
32 static int smoothfade = 0;
33 static int mutelevel = 20;
34 static int muted = 0;
35 static int needfork = 1;
36 static int debug = 0;
37 static int stepsize = 3;
38 static int mixchan = SOUND_MIXER_VOLUME;
39
40 struct subchannel {
41         char *name;
42         struct subchannel *next;
43 };
44
45 static struct channel {
46         char *tech;
47         char *location;
48         struct channel *next;
49         struct subchannel *subs;
50 } *channels;
51
52 static void add_channel(char *tech, char *location)
53 {
54         struct channel *chan;
55         chan = malloc(sizeof(struct channel));
56         if (chan) {
57                 memset(chan, 0, sizeof(struct channel));
58                 chan->tech = strdup(tech);
59                 chan->location = strdup(location);
60                 chan->next = channels;
61                 channels = chan;
62         }
63         
64 }
65
66 static int load_config(void)
67 {
68         FILE *f;
69         char buf[1024];
70         char *val;
71         char *val2;
72         int lineno=0;
73         int x;
74         f = fopen(config, "r");
75         if (!f) {
76                 fprintf(stderr, "Unable to open config file '%s': %s\n", config, strerror(errno));
77                 return -1;
78         }
79         while(!feof(f)) {
80                 fgets(buf, sizeof(buf), f);
81                 if (!feof(f)) {
82                         lineno++;
83                         val = strchr(buf, '#');
84                         if (val) *val = '\0';
85                         while(strlen(buf) && (buf[strlen(buf) - 1] < 33))
86                                 buf[strlen(buf) - 1] = '\0';
87                         if (!strlen(buf))
88                                 continue;
89                         val = buf;
90                         while(*val) {
91                                 if (*val < 33)
92                                         break;
93                                 val++;
94                         }
95                         if (*val) {
96                                 *val = '\0';
97                                 val++;
98                                 while(*val && (*val < 33)) val++;
99                         }
100                         if (!strcasecmp(buf, "host")) {
101                                 if (val && strlen(val))
102                                         strncpy(host, val, sizeof(host) - 1);
103                                 else
104                                         fprintf(stderr, "host needs an argument (the host) at line %d\n", lineno);
105                         } else if (!strcasecmp(buf, "user")) {
106                                 if (val && strlen(val))
107                                         strncpy(user, val, sizeof(user) - 1);
108                                 else
109                                         fprintf(stderr, "user needs an argument (the user) at line %d\n", lineno);
110                         } else if (!strcasecmp(buf, "pass")) {
111                                 if (val && strlen(val))
112                                         strncpy(pass, val, sizeof(pass) - 1);
113                                 else
114                                         fprintf(stderr, "pass needs an argument (the password) at line %d\n", lineno);
115                         } else if (!strcasecmp(buf, "smoothfade")) {
116                                 smoothfade = 1;
117                         } else if (!strcasecmp(buf, "mutelevel")) {
118                                 if (val && (sscanf(val, "%d", &x) == 1) && (x > -1) && (x < 101)) {
119                                         mutelevel = x;
120                                 } else 
121                                         fprintf(stderr, "mutelevel must be a number from 0 (most muted) to 100 (no mute) at line %d\n", lineno);
122                         } else if (!strcasecmp(buf, "channel")) {
123                                 if (val && strlen(val)) {
124                                         val2 = strchr(val, '/');
125                                         if (val2) {
126                                                 *val2 = '\0';
127                                                 val2++;
128                                                 add_channel(val, val2);
129                                         } else
130                                                 fprintf(stderr, "channel needs to be of the format Tech/Location at line %d\n", lineno);
131                                 } else
132                                         fprintf(stderr, "channel needs an argument (the channel) at line %d\n", lineno);
133                         } else {
134                                 fprintf(stderr, "ignoring unknown keyword '%s'\n", buf);
135                         }
136                 }
137         }
138         fclose(f);
139         if (!strlen(host))
140                 fprintf(stderr, "no 'host' specification in config file\n");
141         else if (!strlen(user))
142                 fprintf(stderr, "no 'user' specification in config file\n");
143         else if (!channels) 
144                 fprintf(stderr, "no 'channel' specifications in config file\n");
145         else
146                 return 0;
147         return -1;
148 }
149
150 static FILE *astf;
151
152 static int mixfd;
153
154 static int open_mixer(void)
155 {
156         mixfd = open("/dev/mixer", O_RDWR);
157         if (mixfd < 0) {
158                 fprintf(stderr, "Unable to open /dev/mixer: %s\n", strerror(errno));
159                 return -1;
160         }
161         return 0;
162 }
163
164 static int connect_asterisk(void)
165 {
166         int sock;
167         struct hostent *hp;
168         char *ports;
169         int port = 5038;
170         struct sockaddr_in sin;
171         ports = strchr(host, ':');
172         if (ports) {
173                 *ports = '\0';
174                 ports++;
175                 if ((sscanf(ports, "%d", &port) != 1) || (port < 1) || (port > 65535)) {
176                         fprintf(stderr, "'%s' is not a valid port number in the hostname\n", ports);
177                         return -1;
178                 }
179         }
180         hp = gethostbyname(host);
181         if (!hp) {
182                 fprintf(stderr, "Can't find host '%s'\n", host);
183                 return -1;
184         }
185         sock = socket(AF_INET, SOCK_STREAM, 0);
186         if (sock < 0) {
187                 fprintf(stderr, "Failed to create socket: %s\n", strerror(errno));
188                 return -1;
189         }
190         sin.sin_family = AF_INET;
191         sin.sin_port = htons(port);
192         memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
193         if (connect(sock, &sin, sizeof(sin))) {
194                 fprintf(stderr, "Failed to connect to '%s' port '%d': %s\n", host, port, strerror(errno));
195                 close(sock);
196                 return -1;
197         }
198         astf = fdopen(sock, "r+");
199         if (!astf) {
200                 fprintf(stderr, "fdopen failed: %s\n", strerror(errno));
201                 close(sock);
202                 return -1;
203         }
204         return 0;
205 }
206
207 static char *get_line(void)
208 {
209         static char buf[1024];
210         if (fgets(buf, sizeof(buf), astf)) {
211                 while(strlen(buf) && (buf[strlen(buf) - 1] < 33))
212                         buf[strlen(buf) - 1] = '\0';
213                 return buf;
214         } else
215                 return NULL;
216 }
217
218 static int login_asterisk(void)
219 {
220         char *welcome;
221         char *resp;
222         if (!(welcome = get_line())) {
223                 fprintf(stderr, "disconnected (1)\n");
224                 return -1;
225         }
226         fprintf(astf, 
227                 "Action: Login\r\n"
228                 "Username: %s\r\n"
229                 "Secret: %s\r\n\r\n", user, pass);
230         if (!(welcome = get_line())) {
231                 fprintf(stderr, "disconnected (2)\n");
232                 return -1;
233         }
234         if (strcasecmp(welcome, "Response: Success")) {
235                 fprintf(stderr, "login failed ('%s')\n", welcome);
236                 return -1;
237         }
238         /* Eat the rest of the event */
239         while((resp = get_line()) && strlen(resp));
240         if (!resp) {
241                 fprintf(stderr, "disconnected (3)\n");
242                 return -1;
243         }
244         fprintf(astf, 
245                 "Action: Status\r\n\r\n");
246         if (!(welcome = get_line())) {
247                 fprintf(stderr, "disconnected (4)\n");
248                 return -1;
249         }
250         if (strcasecmp(welcome, "Response: Success")) {
251                 fprintf(stderr, "status failed ('%s')\n", welcome);
252                 return -1;
253         }
254         /* Eat the rest of the event */
255         while((resp = get_line()) && strlen(resp));
256         if (!resp) {
257                 fprintf(stderr, "disconnected (5)\n");
258                 return -1;
259         }
260         return 0;
261 }
262
263 static struct channel *find_channel(char *channel)
264 {
265         char tmp[256] = "";
266         char *s, *t;
267         struct channel *chan;
268         strncpy(tmp, channel, sizeof(tmp) - 1);
269         s = strchr(tmp, '/');
270         if (s) {
271                 *s = '\0';
272                 s++;
273                 t = strrchr(s, '-');
274                 if (t) {
275                         *t = '\0';
276                 }
277                 if (debug)
278                         printf("Searching for '%s' tech, '%s' location\n", tmp, s);
279                 chan = channels;
280                 while(chan) {
281                         if (!strcasecmp(chan->tech, tmp) && !strcasecmp(chan->location, s)) {
282                                 if (debug)
283                                         printf("Found '%s'/'%s'\n", chan->tech, chan->location);
284                                 break;
285                         }
286                         chan = chan->next;
287                 }
288         } else
289                 chan = NULL;
290         return chan;
291 }
292
293 static int getvol(void)
294 {
295         int vol;
296         if (ioctl(mixfd, MIXER_READ(mixchan), &vol)) {
297                 fprintf(stderr, "Unable to read mixer volume: %s\n", strerror(errno));
298                 return -1;
299         }
300         return vol;
301 }
302
303 static int setvol(int vol)
304 {
305         if (ioctl(mixfd, MIXER_WRITE(mixchan), &vol)) {
306                 fprintf(stderr, "Unable to write mixer volume: %s\n", strerror(errno));
307                 return -1;
308         }
309         return 0;
310 }
311
312 static int oldvol = 0;
313 static int mutevol = 0;
314
315 static int mutedlevel(int orig, int mutelevel)
316 {
317         int l = orig >> 8;
318         int r = orig & 0xff;
319         l = (float)(mutelevel) * (float)(l) / 100.0;
320         r = (float)(mutelevel) * (float)(r) / 100.0;
321         return (l << 8) | r;
322 }
323
324 static void mute(void)
325 {
326         int vol;
327         int start;
328         int x;
329         vol = getvol();
330         oldvol = vol;
331         if (smoothfade) 
332                 start = 100;
333         else
334                 start = mutelevel;
335         for (x=start;x>=mutelevel;x-=stepsize) {
336                 mutevol = mutedlevel(vol, x);
337                 setvol(mutevol);
338                 /* Wait 0.01 sec */
339                 usleep(10000);
340         }
341         mutevol = mutedlevel(vol, mutelevel);
342         setvol(mutevol);
343         if (debug)
344                 printf("Mute from '%04x' to '%04x'!\n", oldvol, mutevol);
345         muted = 1;
346 }
347
348 static void unmute(void)
349 {
350         int vol;
351         int start;
352         int x;
353         vol = getvol();
354         if (debug)
355                 printf("Unmute from '%04x' (should be '%04x') to '%04x'!\n", vol, mutevol, oldvol);
356         if (vol == mutevol) {
357                 if (smoothfade)
358                         start = mutelevel;
359                 else
360                         start = 100;
361                 for (x=start;x<100;x+=stepsize) {
362                         mutevol = mutedlevel(oldvol, x);
363                         setvol(mutevol);
364                         /* Wait 0.01 sec */
365                         usleep(10000);
366                 }
367                 setvol(oldvol);
368         } else
369                 printf("Whoops, it's already been changed!\n");
370         muted = 0;
371 }
372
373 static void check_mute(void)
374 {
375         int offhook = 0;
376         struct channel *chan;
377         chan = channels;
378         while(chan) {
379                 if (chan->subs) {
380                         offhook++;
381                         break;
382                 }
383                 chan = chan->next;
384         }
385         if (offhook && !muted)
386                 mute();
387         else if (!offhook && muted)
388                 unmute();
389 }
390
391 static void delete_sub(struct channel *chan, char *name)
392 {
393         struct subchannel *sub, *prev;
394         prev = NULL;
395         sub = chan->subs;
396         while(sub) {
397                 if (!strcasecmp(sub->name, name)) {
398                         if (prev)
399                                 prev->next = sub->next;
400                         else
401                                 chan->subs = sub->next;
402                         free(sub->name);
403                         free(sub);
404                         return;
405                 }
406                 prev = sub;
407                 sub = sub->next;
408         }
409 }
410
411 static void append_sub(struct channel *chan, char *name)
412 {
413         struct subchannel *sub;
414         sub = chan->subs;
415         while(sub) {
416                 if (!strcasecmp(sub->name, name)) 
417                         return;
418                 sub = sub->next;
419         }
420         sub = malloc(sizeof(struct subchannel));
421         if (sub) {
422                 memset(sub, 0, sizeof(struct subchannel));
423                 sub->name = strdup(name);
424                 sub->next = chan->subs;
425                 chan->subs = sub;
426         }
427 }
428
429 static void hangup_chan(char *channel)
430 {
431         struct channel *chan;
432         if (debug)
433                 printf("Hangup '%s'\n", channel);
434         chan = find_channel(channel);
435         if (chan)
436                 delete_sub(chan, channel);
437         check_mute();
438 }
439
440 static void offhook_chan(char *channel)
441 {
442         struct channel *chan;
443         if (debug)
444                 printf("Offhook '%s'\n", channel);
445         chan = find_channel(channel);
446         if (chan)
447                 append_sub(chan, channel);
448         check_mute();
449 }
450
451 static int wait_event(void)
452 {
453         char *resp;
454         char event[120]="";
455         char channel[120]="";
456         char oldname[120]="";
457         char newname[120]="";
458         resp = get_line();
459         if (!resp) {
460                 fprintf(stderr, "disconnected (6)\n");
461                 return -1;
462         }
463         if (!strncasecmp(resp, "Event: ", strlen("Event: "))) {
464                 strncpy(event, resp + strlen("Event: "), sizeof(event) - 1);
465                 /* Consume the rest of the non-event */
466                 while((resp = get_line()) && strlen(resp)) {
467                         if (!strncasecmp(resp, "Channel: ", strlen("Channel: ")))
468                                 strncpy(channel, resp + strlen("Channel: "), sizeof(channel) - 1);
469                         if (!strncasecmp(resp, "Newname: ", strlen("Newname: ")))
470                                 strncpy(newname, resp + strlen("Newname: "), sizeof(newname) - 1);
471                         if (!strncasecmp(resp, "Oldname: ", strlen("Oldname: ")))
472                                 strncpy(oldname, resp + strlen("Oldname: "), sizeof(oldname) - 1);
473                 }
474                 if (strlen(channel)) {
475                         if (!strcasecmp(event, "Hangup")) 
476                                 hangup_chan(channel);
477                         else
478                                 offhook_chan(channel);
479                 }
480                 if (strlen(newname) && strlen(oldname)) {
481                         if (!strcasecmp(event, "Rename")) {
482                                 hangup_chan(oldname);
483                                 offhook_chan(newname);
484                         }
485                 }
486         } else {
487                 /* Consume the rest of the non-event */
488                 while((resp = get_line()) && strlen(resp));
489         }
490         if (!resp) {
491                 fprintf(stderr, "disconnected (7)\n");
492                 return -1;
493         }
494         return 0;
495 }
496
497 static void usage(void)
498 {
499         printf("Usage: muted [-f] [-d]\n"
500                "        -f : Do not fork\n"
501                    "        -d : Debug (implies -f)\n");
502 }
503
504 int main(int argc, char *argv[])
505 {
506         int x;
507         while((x = getopt(argc, argv, "fhd")) > 0) {
508                 switch(x) {
509                 case 'd':
510                         debug = 1;
511                         needfork = 0;
512                         break;
513                 case 'f':
514                         needfork = 0;
515                         break;
516                 case 'h':
517                         /* Fall through */
518                 default:
519                         usage();
520                         exit(1);
521                 }
522         }
523         if (load_config())
524                 exit(1);
525         if (open_mixer())
526                 exit(1);
527         if (connect_asterisk()) {
528                 close(mixfd);
529                 exit(1);
530         }
531         if (login_asterisk()) {
532                 close(mixfd);
533                 fclose(astf);
534                 exit(1);
535         }
536         if (needfork)
537                 daemon(0,0);
538         for(;;) {
539                 if (wait_event()) {
540                         fclose(astf);
541                         while(connect_asterisk()) {
542                                 sleep(5);
543                         }
544                         if (login_asterisk()) {
545                                 fclose(astf);
546                                 exit(1);
547                         }
548                 }
549         }
550         exit(0);
551 }