|
MythTV
0.26-pre
|
|
MythTV
0.26-pre
|
00001 /* NOTE: Extracted from LIRC release 0.8.4a -- dtk */ 00002 /* Updated to LIRC release 0.8.6 */ 00003 /* Modified to use myth_system -- Gavin Hurlbut */ 00004 00005 /**************************************************************************** 00006 ** lirc_client.c *********************************************************** 00007 **************************************************************************** 00008 * 00009 * lirc_client - common routines for lircd clients 00010 * 00011 * Copyright (C) 1998 Trent Piepho <xyzzy@u.washington.edu> 00012 * Copyright (C) 1998 Christoph Bartelmus <lirc@bartelmus.de> 00013 * 00014 * System wide LIRCRC support by Michal Svec <rebel@atrey.karlin.mff.cuni.cz> 00015 */ 00016 00017 #ifdef HAVE_CONFIG_H 00018 # include <config.h> 00019 #endif 00020 00021 #include <errno.h> 00022 #include <unistd.h> 00023 #include <stdio.h> 00024 #include <stdlib.h> 00025 #include <stdarg.h> 00026 #include <string.h> 00027 #include <limits.h> 00028 #include <sys/socket.h> 00029 #include <sys/un.h> 00030 #include <sys/stat.h> 00031 #include <sys/types.h> 00032 #include <sys/wait.h> 00033 00034 #include "lirc_client.h" 00035 #include "mythsystem.h" 00036 00037 00038 /* internal defines */ 00039 #define MAX_INCLUDES 10 00040 #define LIRC_READ 255 00041 #define LIRC_PACKET_SIZE 255 00042 /* three seconds */ 00043 #define LIRC_TIMEOUT 3 00044 00045 /* internal data structures */ 00046 struct filestack_t { 00047 FILE *file; 00048 char *name; 00049 int line; 00050 struct filestack_t *parent; 00051 }; 00052 00053 enum packet_state 00054 { 00055 P_BEGIN, 00056 P_MESSAGE, 00057 P_STATUS, 00058 P_DATA, 00059 P_N, 00060 P_DATA_N, 00061 P_END 00062 }; 00063 00064 /* internal functions */ 00065 static void lirc_printf(const struct lirc_state*, const char *format_str, ...); 00066 static void lirc_perror(const struct lirc_state*, const char *s); 00067 static int lirc_readline(const struct lirc_state *state, char **line,FILE *f); 00068 static char *lirc_trim(char *s); 00069 static char lirc_parse_escape(const struct lirc_state *state, char **s,const char *name,int line); 00070 static void lirc_parse_string(const struct lirc_state *state, char *s,const char *name,int line); 00071 static void lirc_parse_include(char *s,const char *name,int line); 00072 static int lirc_mode( 00073 const struct lirc_state *state, 00074 const char *token,const char *token2,char **mode, 00075 struct lirc_config_entry **new_config, 00076 struct lirc_config_entry **first_config, 00077 struct lirc_config_entry **last_config, 00078 int (check)(char *s), 00079 const char *name,int line); 00080 /* 00081 lircrc_config relies on this function, hence don't make it static 00082 but it's not part of the official interface, so there's no guarantee 00083 that it will stay available in the future 00084 */ 00085 static unsigned int lirc_flags(const struct lirc_state *state, char *string); 00086 static char *lirc_getfilename(const struct lirc_state *state, 00087 const char *file, 00088 const char *current_file); 00089 static FILE *lirc_open(const struct lirc_state *state, 00090 const char *file, const char *current_file, 00091 char **full_name); 00092 static struct filestack_t *stack_push(const struct lirc_state *state, struct filestack_t *parent); 00093 static struct filestack_t *stack_pop(struct filestack_t *entry); 00094 static void stack_free(struct filestack_t *entry); 00095 static int lirc_readconfig_only_internal(const struct lirc_state *state, 00096 const char *file, 00097 struct lirc_config **config, 00098 int (check)(char *s), 00099 char **full_name, 00100 char **sha_bang); 00101 static char *lirc_startupmode(const struct lirc_state *state, 00102 struct lirc_config_entry *first); 00103 static void lirc_freeconfigentries(struct lirc_config_entry *first); 00104 static void lirc_clearmode(struct lirc_config *config); 00105 static char *lirc_execute(const struct lirc_state *state, 00106 struct lirc_config *config, 00107 struct lirc_config_entry *scan); 00108 static int lirc_iscode(struct lirc_config_entry *scan, char *remote, 00109 char *button,int rep); 00110 static int lirc_code2char_internal(const struct lirc_state *state, 00111 struct lirc_config *config,char *code, 00112 char **string, char **prog); 00113 static const char *lirc_read_string(const struct lirc_state *state, int fd); 00114 static int lirc_identify(const struct lirc_state *state, int sockfd); 00115 00116 static int lirc_send_command(const struct lirc_state *state, int sockfd, const char *command, char *buf, size_t *buf_len, int *ret_status); 00117 00118 static void lirc_printf(const struct lirc_state *state, const char *format_str, ...) 00119 { 00120 va_list ap; 00121 00122 if(state && !state->lirc_verbose) return; 00123 00124 va_start(ap,format_str); 00125 vfprintf(stderr,format_str,ap); 00126 va_end(ap); 00127 } 00128 00129 static void lirc_perror(const struct lirc_state *state, const char *s) 00130 { 00131 if(!state->lirc_verbose) return; 00132 00133 perror(s); 00134 } 00135 00136 struct lirc_state *lirc_init(const char *lircrc_root_file, 00137 const char *lircrc_user_file, 00138 const char *prog, 00139 const char *lircd, 00140 int verbose) 00141 { 00142 struct sockaddr_un addr; 00143 00144 /* connect to lircd */ 00145 00146 if(lircrc_root_file==NULL || lircrc_user_file == NULL || prog==NULL) 00147 { 00148 lirc_printf(NULL, "%s: lirc_init invalid params\n",prog); 00149 return(NULL); 00150 } 00151 00152 struct lirc_state *state = (struct lirc_state *) calloc(1, sizeof(struct lirc_state)); 00153 if(state==NULL) 00154 { 00155 lirc_printf(NULL, "%s: out of memory\n",prog); 00156 return(NULL); 00157 } 00158 state->lirc_lircd=-1; 00159 state->lirc_verbose=verbose; 00160 00161 state->lircrc_root_file=strdup(lircrc_root_file); 00162 if(state->lircrc_root_file==NULL) 00163 { 00164 lirc_printf(state, "%s: out of memory\n",prog); 00165 lirc_deinit(state); 00166 return(NULL); 00167 } 00168 00169 state->lircrc_user_file=strdup(lircrc_user_file); 00170 if(state->lircrc_user_file==NULL) 00171 { 00172 lirc_printf(state, "%s: out of memory\n",prog); 00173 lirc_deinit(state); 00174 return(NULL); 00175 } 00176 00177 state->lirc_prog=strdup(prog); 00178 if(state->lirc_prog==NULL) 00179 { 00180 lirc_printf(state, "%s: out of memory\n",prog); 00181 lirc_deinit(state); 00182 return(NULL); 00183 } 00184 00185 if (lircd) 00186 { 00187 addr.sun_family=AF_UNIX; 00188 strncpy(addr.sun_path,lircd,sizeof(addr.sun_path)-1); 00189 state->lirc_lircd=socket(AF_UNIX,SOCK_STREAM,0); 00190 if(state->lirc_lircd==-1) 00191 { 00192 lirc_printf(state, "%s: could not open socket\n",state->lirc_prog); 00193 lirc_perror(state, state->lirc_prog); 00194 lirc_deinit(state); 00195 return(NULL); 00196 } 00197 if(connect(state->lirc_lircd,(struct sockaddr *)&addr,sizeof(addr))==-1) 00198 { 00199 close(state->lirc_lircd); 00200 lirc_printf(state, "%s: could not connect to socket\n",state->lirc_prog); 00201 lirc_perror(state, state->lirc_prog); 00202 lirc_deinit(state); 00203 return(NULL); 00204 } 00205 } 00206 00207 return(state); 00208 } 00209 00210 int lirc_deinit(struct lirc_state *state) 00211 { 00212 int ret = LIRC_RET_SUCCESS; 00213 if (state==NULL) 00214 return ret; 00215 if(state->lircrc_root_file!=NULL) 00216 { 00217 free(state->lircrc_root_file); 00218 state->lircrc_root_file=NULL; 00219 } 00220 if(state->lircrc_user_file!=NULL) 00221 { 00222 free(state->lircrc_user_file); 00223 state->lircrc_user_file=NULL; 00224 } 00225 if(state->lirc_prog!=NULL) 00226 { 00227 free(state->lirc_prog); 00228 state->lirc_prog=NULL; 00229 } 00230 if(state->lirc_buffer!=NULL) 00231 { 00232 free(state->lirc_buffer); 00233 state->lirc_buffer=NULL; 00234 } 00235 if (state->lirc_lircd!=-1) 00236 ret = close(state->lirc_lircd); 00237 free(state); 00238 return ret; 00239 } 00240 00241 static int lirc_readline(const struct lirc_state *state, char **line,FILE *f) 00242 { 00243 char *newline,*ret,*enlargeline; 00244 int len; 00245 00246 newline=(char *) malloc(LIRC_READ+1); 00247 if(newline==NULL) 00248 { 00249 lirc_printf(state, "%s: out of memory\n",state->lirc_prog); 00250 return(-1); 00251 } 00252 len=0; 00253 while(1) 00254 { 00255 ret=fgets(newline+len,LIRC_READ+1,f); 00256 if(ret==NULL) 00257 { 00258 if(feof(f) && len>0) 00259 { 00260 *line=newline; 00261 } 00262 else 00263 { 00264 free(newline); 00265 *line=NULL; 00266 } 00267 return(0); 00268 } 00269 len=strlen(newline); 00270 if(newline[len-1]=='\n') 00271 { 00272 newline[len-1]=0; 00273 *line=newline; 00274 return(0); 00275 } 00276 00277 enlargeline=(char *) realloc(newline,len+1+LIRC_READ); 00278 if(enlargeline==NULL) 00279 { 00280 free(newline); 00281 lirc_printf(state, "%s: out of memory\n",state->lirc_prog); 00282 return(-1); 00283 } 00284 newline=enlargeline; 00285 } 00286 } 00287 00288 static char *lirc_trim(char *s) 00289 { 00290 int len; 00291 00292 while(s[0]==' ' || s[0]=='\t') s++; 00293 len=strlen(s); 00294 while(len>0) 00295 { 00296 len--; 00297 if(s[len]==' ' || s[len]=='\t') s[len]=0; 00298 else break; 00299 } 00300 return(s); 00301 } 00302 00303 /* parse standard C escape sequences + \@,\A-\Z is ^@,^A-^Z */ 00304 00305 static char lirc_parse_escape(const struct lirc_state *state, char **s,const char *name,int line) 00306 { 00307 00308 char c; 00309 unsigned int i,overflow,count; 00310 int digits_found,digit; 00311 00312 c=**s; 00313 (*s)++; 00314 switch(c) 00315 { 00316 case 'a': 00317 return('\a'); 00318 case 'b': 00319 return('\b'); 00320 case 'e': 00321 #if 0 00322 case 'E': /* this should become ^E */ 00323 #endif 00324 return(033); 00325 case 'f': 00326 return('\f'); 00327 case 'n': 00328 return('\n'); 00329 case 'r': 00330 return('\r'); 00331 case 't': 00332 return('\t'); 00333 case 'v': 00334 return('\v'); 00335 case '\n': 00336 return(0); 00337 case 0: 00338 (*s)--; 00339 return 0; 00340 case '0': 00341 case '1': 00342 case '2': 00343 case '3': 00344 case '4': 00345 case '5': 00346 case '6': 00347 case '7': 00348 i=c-'0'; 00349 count=0; 00350 00351 while(++count<3) 00352 { 00353 c=*(*s)++; 00354 if(c>='0' && c<='7') 00355 { 00356 i=(i << 3)+c-'0'; 00357 } 00358 else 00359 { 00360 (*s)--; 00361 break; 00362 } 00363 } 00364 if(i>(1<<CHAR_BIT)-1) 00365 { 00366 i&=(1<<CHAR_BIT)-1; 00367 lirc_printf(state, "%s: octal escape sequence " 00368 "out of range in %s:%d\n",state->lirc_prog, 00369 name,line); 00370 } 00371 return((char) i); 00372 case 'x': 00373 { 00374 i=0; 00375 overflow=0; 00376 digits_found=0; 00377 for (;;) 00378 { 00379 c = *(*s)++; 00380 if(c>='0' && c<='9') 00381 digit=c-'0'; 00382 else if(c>='a' && c<='f') 00383 digit=c-'a'+10; 00384 else if(c>='A' && c<='F') 00385 digit=c-'A'+10; 00386 else 00387 { 00388 (*s)--; 00389 break; 00390 } 00391 overflow|=i^(i<<4>>4); 00392 i=(i<<4)+digit; 00393 digits_found=1; 00394 } 00395 if(!digits_found) 00396 { 00397 lirc_printf(state, "%s: \\x used with no " 00398 "following hex digits in %s:%d\n", 00399 state->lirc_prog,name,line); 00400 } 00401 if(overflow || i>(1<<CHAR_BIT)-1) 00402 { 00403 i&=(1<<CHAR_BIT)-1; 00404 lirc_printf(state, "%s: hex escape sequence out " 00405 "of range in %s:%d\n", 00406 state->lirc_prog,name,line); 00407 } 00408 return((char) i); 00409 } 00410 default: 00411 if(c>='@' && c<='Z') return(c-'@'); 00412 return(c); 00413 } 00414 } 00415 00416 static void lirc_parse_string(const struct lirc_state *state, char *s,const char *name,int line) 00417 { 00418 char *t; 00419 00420 t=s; 00421 while(*s!=0) 00422 { 00423 if(*s=='\\') 00424 { 00425 s++; 00426 *t=lirc_parse_escape(state, &s,name,line); 00427 t++; 00428 } 00429 else 00430 { 00431 *t=*s; 00432 s++; 00433 t++; 00434 } 00435 } 00436 *t=0; 00437 } 00438 00439 static void lirc_parse_include(char *s,const char *name,int line) 00440 { 00441 char last; 00442 size_t len; 00443 00444 len=strlen(s); 00445 if(len<2) 00446 { 00447 return; 00448 } 00449 last=s[len-1]; 00450 if(*s!='"' && *s!='<') 00451 { 00452 return; 00453 } 00454 if(*s=='"' && last!='"') 00455 { 00456 return; 00457 } 00458 else if(*s=='<' && last!='>') 00459 { 00460 return; 00461 } 00462 s[len-1]=0; 00463 memmove(s, s+1, len-2+1); /* terminating 0 is copied */ 00464 } 00465 00466 int lirc_mode(const struct lirc_state *state, 00467 const char *token,const char *token2,char **mode, 00468 struct lirc_config_entry **new_config, 00469 struct lirc_config_entry **first_config, 00470 struct lirc_config_entry **last_config, 00471 int (check)(char *s), 00472 const char *name,int line) 00473 { 00474 struct lirc_config_entry *new_entry; 00475 00476 new_entry=*new_config; 00477 if(strcasecmp(token,"begin")==0) 00478 { 00479 if(token2==NULL) 00480 { 00481 if(new_entry==NULL) 00482 { 00483 new_entry=(struct lirc_config_entry *) 00484 malloc(sizeof(struct lirc_config_entry)); 00485 if(new_entry==NULL) 00486 { 00487 lirc_printf(state, "%s: out of memory\n", 00488 state->lirc_prog); 00489 return(-1); 00490 } 00491 else 00492 { 00493 new_entry->prog=NULL; 00494 new_entry->code=NULL; 00495 new_entry->rep_delay=0; 00496 new_entry->rep=0; 00497 new_entry->config=NULL; 00498 new_entry->change_mode=NULL; 00499 new_entry->flags=none; 00500 new_entry->mode=NULL; 00501 new_entry->next_config=NULL; 00502 new_entry->next_code=NULL; 00503 new_entry->next=NULL; 00504 00505 *new_config=new_entry; 00506 } 00507 } 00508 else 00509 { 00510 lirc_printf(state, "%s: bad file format, " 00511 "%s:%d\n",state->lirc_prog,name,line); 00512 return(-1); 00513 } 00514 } 00515 else 00516 { 00517 if(new_entry==NULL && *mode==NULL) 00518 { 00519 *mode=strdup(token2); 00520 if(*mode==NULL) 00521 { 00522 return(-1); 00523 } 00524 } 00525 else 00526 { 00527 lirc_printf(state, "%s: bad file format, " 00528 "%s:%d\n",state->lirc_prog,name,line); 00529 return(-1); 00530 } 00531 } 00532 } 00533 else if(strcasecmp(token,"end")==0) 00534 { 00535 if(token2==NULL) 00536 { 00537 if(new_entry!=NULL) 00538 { 00539 #if 0 00540 if(new_entry->prog==NULL) 00541 { 00542 lirc_printf(state, "%s: prog missing in " 00543 "config before line %d\n", 00544 state->lirc_prog,line); 00545 lirc_freeconfigentries(new_entry); 00546 *new_config=NULL; 00547 return(-1); 00548 } 00549 if(strcasecmp(new_entry->prog,state->lirc_prog)!=0) 00550 { 00551 lirc_freeconfigentries(new_entry); 00552 *new_config=NULL; 00553 return(0); 00554 } 00555 #endif 00556 new_entry->next_code=new_entry->code; 00557 new_entry->next_config=new_entry->config; 00558 if(*last_config==NULL) 00559 { 00560 *first_config=new_entry; 00561 *last_config=new_entry; 00562 } 00563 else 00564 { 00565 (*last_config)->next=new_entry; 00566 *last_config=new_entry; 00567 } 00568 *new_config=NULL; 00569 00570 if(*mode!=NULL) 00571 { 00572 new_entry->mode=strdup(*mode); 00573 if(new_entry->mode==NULL) 00574 { 00575 lirc_printf(state, "%s: out of " 00576 "memory\n", 00577 state->lirc_prog); 00578 return(-1); 00579 } 00580 } 00581 00582 if(check!=NULL && 00583 new_entry->prog!=NULL && 00584 strcasecmp(new_entry->prog,state->lirc_prog)==0) 00585 { 00586 struct lirc_list *list; 00587 00588 list=new_entry->config; 00589 while(list!=NULL) 00590 { 00591 if(check(list->string)==-1) 00592 { 00593 return(-1); 00594 } 00595 list=list->next; 00596 } 00597 } 00598 00599 if (new_entry->rep_delay==0 && 00600 new_entry->rep>0) 00601 { 00602 new_entry->rep_delay=new_entry->rep-1; 00603 } 00604 } 00605 else 00606 { 00607 lirc_printf(state, "%s: %s:%d: 'end' without " 00608 "'begin'\n",state->lirc_prog,name,line); 00609 return(-1); 00610 } 00611 } 00612 else 00613 { 00614 if(*mode!=NULL) 00615 { 00616 if(new_entry!=NULL) 00617 { 00618 lirc_printf(state, "%s: %s:%d: missing " 00619 "'end' token\n",state->lirc_prog, 00620 name,line); 00621 return(-1); 00622 } 00623 if(strcasecmp(*mode,token2)==0) 00624 { 00625 free(*mode); 00626 *mode=NULL; 00627 } 00628 else 00629 { 00630 lirc_printf(state, "%s: \"%s\" doesn't " 00631 "match mode \"%s\"\n", 00632 state->lirc_prog,token2,*mode); 00633 return(-1); 00634 } 00635 } 00636 else 00637 { 00638 lirc_printf(state, "%s: %s:%d: 'end %s' without " 00639 "'begin'\n",state->lirc_prog,name,line, 00640 token2); 00641 return(-1); 00642 } 00643 } 00644 } 00645 else 00646 { 00647 lirc_printf(state, "%s: unknown token \"%s\" in %s:%d ignored\n", 00648 state->lirc_prog,token,name,line); 00649 } 00650 return(0); 00651 } 00652 00653 unsigned int lirc_flags(const struct lirc_state *state, char *string) 00654 { 00655 char *s, *strtok_state = NULL; 00656 unsigned int flags; 00657 00658 flags=none; 00659 s=strtok_r(string," \t|",&strtok_state); 00660 while(s) 00661 { 00662 if(strcasecmp(s,"once")==0) 00663 { 00664 flags|=once; 00665 } 00666 else if(strcasecmp(s,"quit")==0) 00667 { 00668 flags|=quit; 00669 } 00670 else if(strcasecmp(s,"mode")==0) 00671 { 00672 flags|=mode; 00673 } 00674 else if(strcasecmp(s,"startup_mode")==0) 00675 { 00676 flags|=startup_mode; 00677 } 00678 else if(strcasecmp(s,"toggle_reset")==0) 00679 { 00680 flags|=toggle_reset; 00681 } 00682 else 00683 { 00684 lirc_printf(state, "%s: unknown flag \"%s\"\n",state->lirc_prog,s); 00685 } 00686 s=strtok_r(NULL," \t",&strtok_state); 00687 } 00688 return(flags); 00689 } 00690 00691 static char *lirc_getfilename(const struct lirc_state *state, 00692 const char *file, 00693 const char *current_file) 00694 { 00695 const char *home; 00696 char *filename; 00697 00698 if(file==NULL) 00699 { 00700 home=getenv("HOME"); 00701 if(home==NULL) 00702 { 00703 home="/"; 00704 } 00705 filename=(char *) malloc(strlen(home)+1+ 00706 strlen(state->lircrc_user_file)+1); 00707 if(filename==NULL) 00708 { 00709 lirc_printf(state, "%s: out of memory\n",state->lirc_prog); 00710 return NULL; 00711 } 00712 strcpy(filename,home); 00713 if(strlen(home)>0 && filename[strlen(filename)-1]!='/') 00714 { 00715 strcat(filename,"/"); 00716 } 00717 strcat(filename,state->lircrc_user_file); 00718 } 00719 else if(strncmp(file, "~/", 2)==0) 00720 { 00721 home=getenv("HOME"); 00722 if(home==NULL) 00723 { 00724 home="/"; 00725 } 00726 filename=(char *) malloc(strlen(home)+strlen(file)+1); 00727 if(filename==NULL) 00728 { 00729 lirc_printf(state, "%s: out of memory\n",state->lirc_prog); 00730 return NULL; 00731 } 00732 strcpy(filename,home); 00733 strcat(filename,file+1); 00734 } 00735 else if(file[0]=='/' || current_file==NULL) 00736 { 00737 /* absulute path or root */ 00738 filename=strdup(file); 00739 if(filename==NULL) 00740 { 00741 lirc_printf(state, "%s: out of memory\n",state->lirc_prog); 00742 return NULL; 00743 } 00744 } 00745 else 00746 { 00747 /* get path from parent filename */ 00748 int pathlen = strlen(current_file); 00749 while (pathlen>0 && current_file[pathlen-1]!='/') 00750 pathlen--; 00751 filename=(char *) malloc(pathlen+strlen(file)+1); 00752 if(filename==NULL) 00753 { 00754 lirc_printf(state, "%s: out of memory\n",state->lirc_prog); 00755 return NULL; 00756 } 00757 memcpy(filename,current_file,pathlen); 00758 filename[pathlen]=0; 00759 strcat(filename,file); 00760 } 00761 return filename; 00762 } 00763 00764 static FILE *lirc_open(const struct lirc_state *state, 00765 const char *file, const char *current_file, 00766 char **full_name) 00767 { 00768 FILE *fin; 00769 char *filename; 00770 00771 filename=lirc_getfilename(state, file, current_file); 00772 if(filename==NULL) 00773 { 00774 return NULL; 00775 } 00776 00777 fin=fopen(filename,"r"); 00778 if(fin==NULL && (file!=NULL || errno!=ENOENT)) 00779 { 00780 lirc_printf(state, "%s: could not open config file %s\n", 00781 state->lirc_prog,filename); 00782 lirc_perror(state, state->lirc_prog); 00783 } 00784 else if(fin==NULL) 00785 { 00786 fin=fopen(state->lircrc_root_file,"r"); 00787 if(fin==NULL && errno!=ENOENT) 00788 { 00789 lirc_printf(state, "%s: could not open config file %s\n", 00790 state->lirc_prog,state->lircrc_root_file); 00791 lirc_perror(state, state->lirc_prog); 00792 } 00793 else if(fin==NULL) 00794 { 00795 lirc_printf(state, "%s: could not open config files " 00796 "%s and %s\n", 00797 state->lirc_prog,filename,state->lircrc_root_file); 00798 lirc_perror(state, state->lirc_prog); 00799 } 00800 else 00801 { 00802 free(filename); 00803 filename = strdup(state->lircrc_root_file); 00804 if(filename==NULL) 00805 { 00806 fclose(fin); 00807 lirc_printf(state, "%s: out of memory\n",state->lirc_prog); 00808 return NULL; 00809 } 00810 } 00811 } 00812 if(full_name && fin!=NULL) 00813 { 00814 *full_name = filename; 00815 } 00816 else 00817 { 00818 free(filename); 00819 } 00820 return fin; 00821 } 00822 00823 static struct filestack_t *stack_push(const struct lirc_state *state, struct filestack_t *parent) 00824 { 00825 struct filestack_t *entry; 00826 entry = malloc(sizeof(struct filestack_t)); 00827 if (entry == NULL) 00828 { 00829 lirc_printf(state, "%s: out of memory\n",state->lirc_prog); 00830 return NULL; 00831 } 00832 entry->file = NULL; 00833 entry->name = NULL; 00834 entry->line = 0; 00835 entry->parent = parent; 00836 return entry; 00837 } 00838 00839 static struct filestack_t *stack_pop(struct filestack_t *entry) 00840 { 00841 struct filestack_t *parent = NULL; 00842 if (entry) 00843 { 00844 parent = entry->parent; 00845 if (entry->name) 00846 free(entry->name); 00847 free(entry); 00848 } 00849 return parent; 00850 } 00851 00852 static void stack_free(struct filestack_t *entry) 00853 { 00854 while (entry) 00855 { 00856 entry = stack_pop(entry); 00857 } 00858 } 00859 00860 int lirc_readconfig(const struct lirc_state *state, 00861 const char *file, 00862 struct lirc_config **config, 00863 int (check)(char *s)) 00864 { 00865 struct sockaddr_un addr; 00866 int sockfd = -1; 00867 char *sha_bang, *filename; 00868 const char *sha_bang2; 00869 char *command; 00870 unsigned int ret; 00871 00872 filename = NULL; 00873 sha_bang = NULL; 00874 if(lirc_readconfig_only_internal(state,file,config,check,&filename,&sha_bang)==-1) 00875 { 00876 return -1; 00877 } 00878 00879 if(sha_bang == NULL) 00880 { 00881 goto lirc_readconfig_compat; 00882 } 00883 00884 /* connect to lircrcd */ 00885 00886 addr.sun_family=AF_UNIX; 00887 if(lirc_getsocketname(filename, addr.sun_path, sizeof(addr.sun_path))>sizeof(addr.sun_path)) 00888 { 00889 lirc_printf(state, "%s: WARNING: file name too long\n", state->lirc_prog); 00890 goto lirc_readconfig_compat; 00891 } 00892 sockfd=socket(AF_UNIX,SOCK_STREAM,0); 00893 if(sockfd==-1) 00894 { 00895 lirc_printf(state, "%s: WARNING: could not open socket\n",state->lirc_prog); 00896 lirc_perror(state, state->lirc_prog); 00897 goto lirc_readconfig_compat; 00898 } 00899 if(connect(sockfd, (struct sockaddr *)&addr, sizeof(addr))!=-1) 00900 { 00901 if(sha_bang!=NULL) free(sha_bang); 00902 (*config)->sockfd=sockfd; 00903 free(filename); 00904 00905 /* tell daemon state->lirc_prog */ 00906 if(lirc_identify(state, sockfd) == LIRC_RET_SUCCESS) 00907 { 00908 /* we're connected */ 00909 return 0; 00910 } 00911 close(sockfd); 00912 lirc_freeconfig(*config); 00913 return -1; 00914 } 00915 close(sockfd); 00916 sockfd = -1; 00917 00918 /* launch lircrcd */ 00919 sha_bang2=sha_bang!=NULL ? sha_bang:"lircrcd"; 00920 00921 command=malloc(strlen(sha_bang2)+1+strlen(filename)+1); 00922 if(command==NULL) 00923 { 00924 goto lirc_readconfig_compat; 00925 } 00926 strcpy(command, sha_bang2); 00927 strcat(command, " "); 00928 strcat(command, filename); 00929 00930 ret = myth_system_c(command, kMSNone, 0); 00931 free(command); 00932 00933 if(ret!=EXIT_SUCCESS) 00934 { 00935 goto lirc_readconfig_compat; 00936 } 00937 00938 if(sha_bang!=NULL) { free(sha_bang); sha_bang = NULL; } 00939 free(filename); filename = NULL; 00940 00941 sockfd=socket(AF_UNIX,SOCK_STREAM,0); 00942 if(sockfd==-1) 00943 { 00944 lirc_printf(state, "%s: WARNING: could not open socket\n",state->lirc_prog); 00945 lirc_perror(state, state->lirc_prog); 00946 goto lirc_readconfig_compat; 00947 } 00948 if(connect(sockfd, (struct sockaddr *)&addr, sizeof(addr))!=-1) 00949 { 00950 if(lirc_identify(state, sockfd) == LIRC_RET_SUCCESS) 00951 { 00952 (*config)->sockfd=sockfd; 00953 return 0; 00954 } 00955 } 00956 close(sockfd); 00957 lirc_freeconfig(*config); 00958 return -1; 00959 00960 lirc_readconfig_compat: 00961 /* compat fallback */ 00962 if(sockfd != -1) close(sockfd); 00963 if(sha_bang!=NULL) free(sha_bang); 00964 free(filename); 00965 return 0; 00966 } 00967 00968 int lirc_readconfig_only(const struct lirc_state *state, 00969 const char *file, 00970 struct lirc_config **config, 00971 int (check)(char *s)) 00972 { 00973 return lirc_readconfig_only_internal(state, file, config, check, NULL, NULL); 00974 } 00975 00976 static int lirc_readconfig_only_internal(const struct lirc_state *state, 00977 const char *file, 00978 struct lirc_config **config, 00979 int (check)(char *s), 00980 char **full_name, 00981 char **sha_bang) 00982 { 00983 char *string,*eq,*token,*token2,*token3,*strtok_state = NULL; 00984 struct filestack_t *filestack, *stack_tmp; 00985 int open_files; 00986 struct lirc_config_entry *new_entry,*first,*last; 00987 char *mode,*remote; 00988 int ret=0; 00989 int firstline=1; 00990 char *save_full_name = NULL; 00991 00992 filestack = stack_push(state, NULL); 00993 if (filestack == NULL) 00994 { 00995 return -1; 00996 } 00997 filestack->file = lirc_open(state, file, NULL, &(filestack->name)); 00998 if (filestack->file == NULL) 00999 { 01000 stack_free(filestack); 01001 return -1; 01002 } 01003 filestack->line = 0; 01004 open_files = 1; 01005 01006 first=new_entry=last=NULL; 01007 mode=NULL; 01008 remote=LIRC_ALL; 01009 while (filestack) 01010 { 01011 if((ret=lirc_readline(state,&string,filestack->file))==-1 || 01012 string==NULL) 01013 { 01014 fclose(filestack->file); 01015 if(open_files == 1 && full_name != NULL) 01016 { 01017 save_full_name = filestack->name; 01018 filestack->name = NULL; 01019 } 01020 filestack = stack_pop(filestack); 01021 open_files--; 01022 continue; 01023 } 01024 /* check for sha-bang */ 01025 if(firstline && sha_bang) 01026 { 01027 firstline = 0; 01028 if(strncmp(string, "#!", 2)==0) 01029 { 01030 *sha_bang=strdup(string+2); 01031 if(*sha_bang==NULL) 01032 { 01033 lirc_printf(state, "%s: out of memory\n", 01034 state->lirc_prog); 01035 ret=-1; 01036 free(string); 01037 break; 01038 } 01039 } 01040 } 01041 filestack->line++; 01042 eq=strchr(string,'='); 01043 if(eq==NULL) 01044 { 01045 token=strtok_r(string," \t",&strtok_state); 01046 if(token==NULL) 01047 { 01048 /* ignore empty line */ 01049 } 01050 else if(token[0]=='#') 01051 { 01052 /* ignore comment */ 01053 } 01054 else if(strcasecmp(token, "include") == 0) 01055 { 01056 if (open_files >= MAX_INCLUDES) 01057 { 01058 lirc_printf(state, "%s: too many files " 01059 "included at %s:%d\n", 01060 state->lirc_prog, 01061 filestack->name, 01062 filestack->line); 01063 ret=-1; 01064 } 01065 else 01066 { 01067 token2 = strtok_r(NULL, "", &strtok_state); 01068 token2 = lirc_trim(token2); 01069 lirc_parse_include 01070 (token2, filestack->name, 01071 filestack->line); 01072 stack_tmp = stack_push(state, filestack); 01073 if (stack_tmp == NULL) 01074 { 01075 ret=-1; 01076 } 01077 else 01078 { 01079 stack_tmp->file = lirc_open(state, token2, filestack->name, &(stack_tmp->name)); 01080 stack_tmp->line = 0; 01081 if (stack_tmp->file) 01082 { 01083 open_files++; 01084 filestack = stack_tmp; 01085 } 01086 else 01087 { 01088 stack_pop(stack_tmp); 01089 ret=-1; 01090 } 01091 } 01092 } 01093 } 01094 else 01095 { 01096 token2=strtok_r(NULL," \t",&strtok_state); 01097 if(token2!=NULL && 01098 (token3=strtok_r(NULL," \t",&strtok_state))!=NULL) 01099 { 01100 lirc_printf(state, "%s: unexpected token in line %s:%d\n", 01101 state->lirc_prog,filestack->name,filestack->line); 01102 } 01103 else 01104 { 01105 ret=lirc_mode(state, token,token2,&mode, 01106 &new_entry,&first,&last, 01107 check, 01108 filestack->name, 01109 filestack->line); 01110 if(ret==0) 01111 { 01112 if(remote!=LIRC_ALL) 01113 free(remote); 01114 remote=LIRC_ALL; 01115 } 01116 else 01117 { 01118 if(mode!=NULL) 01119 { 01120 free(mode); 01121 mode=NULL; 01122 } 01123 if(new_entry!=NULL) 01124 { 01125 lirc_freeconfigentries 01126 (new_entry); 01127 new_entry=NULL; 01128 } 01129 } 01130 } 01131 } 01132 } 01133 else 01134 { 01135 eq[0]=0; 01136 token=lirc_trim(string); 01137 token2=lirc_trim(eq+1); 01138 if(token[0]=='#') 01139 { 01140 /* ignore comment */ 01141 } 01142 else if(new_entry==NULL) 01143 { 01144 lirc_printf(state, "%s: bad file format, %s:%d\n", 01145 state->lirc_prog,filestack->name,filestack->line); 01146 ret=-1; 01147 } 01148 else 01149 { 01150 token2=strdup(token2); 01151 if(token2==NULL) 01152 { 01153 lirc_printf(state, "%s: out of memory\n", 01154 state->lirc_prog); 01155 ret=-1; 01156 } 01157 else if(strcasecmp(token,"prog")==0) 01158 { 01159 if(new_entry->prog!=NULL) free(new_entry->prog); 01160 new_entry->prog=token2; 01161 } 01162 else if(strcasecmp(token,"remote")==0) 01163 { 01164 if(remote!=LIRC_ALL) 01165 free(remote); 01166 01167 if(strcasecmp("*",token2)==0) 01168 { 01169 remote=LIRC_ALL; 01170 free(token2); 01171 } 01172 else 01173 { 01174 remote=token2; 01175 } 01176 } 01177 else if(strcasecmp(token,"button")==0) 01178 { 01179 struct lirc_code *code; 01180 01181 code=(struct lirc_code *) 01182 malloc(sizeof(struct lirc_code)); 01183 if(code==NULL) 01184 { 01185 free(token2); 01186 lirc_printf(state, "%s: out of " 01187 "memory\n", 01188 state->lirc_prog); 01189 ret=-1; 01190 } 01191 else 01192 { 01193 code->remote=remote; 01194 if(strcasecmp("*",token2)==0) 01195 { 01196 code->button=LIRC_ALL; 01197 free(token2); 01198 } 01199 else 01200 { 01201 code->button=token2; 01202 } 01203 code->next=NULL; 01204 01205 if(new_entry->code==NULL) 01206 { 01207 new_entry->code=code; 01208 } 01209 else 01210 { 01211 new_entry->next_code->next 01212 =code; 01213 } 01214 new_entry->next_code=code; 01215 if(remote!=LIRC_ALL) 01216 { 01217 remote=strdup(remote); 01218 if(remote==NULL) 01219 { 01220 lirc_printf(state, "%s: out of memory\n",state->lirc_prog); 01221 ret=-1; 01222 } 01223 } 01224 } 01225 } 01226 else if(strcasecmp(token,"delay")==0) 01227 { 01228 char *end; 01229 01230 errno=ERANGE+1; 01231 new_entry->rep_delay=strtoul(token2,&end,0); 01232 if((new_entry->rep_delay==UINT_MAX 01233 && errno==ERANGE) 01234 || end[0]!=0 01235 || strlen(token2)==0) 01236 { 01237 lirc_printf(state, "%s: \"%s\" not" 01238 " a valid number for " 01239 "delay\n",state->lirc_prog, 01240 token2); 01241 } 01242 free(token2); 01243 } 01244 else if(strcasecmp(token,"repeat")==0) 01245 { 01246 char *end; 01247 01248 errno=ERANGE+1; 01249 new_entry->rep=strtoul(token2,&end,0); 01250 if((new_entry->rep==UINT_MAX 01251 && errno==ERANGE) 01252 || end[0]!=0 01253 || strlen(token2)==0) 01254 { 01255 lirc_printf(state, "%s: \"%s\" not" 01256 " a valid number for " 01257 "repeat\n",state->lirc_prog, 01258 token2); 01259 } 01260 free(token2); 01261 } 01262 else if(strcasecmp(token,"config")==0) 01263 { 01264 struct lirc_list *new_list; 01265 01266 new_list=(struct lirc_list *) 01267 malloc(sizeof(struct lirc_list)); 01268 if(new_list==NULL) 01269 { 01270 free(token2); 01271 lirc_printf(state, "%s: out of " 01272 "memory\n", 01273 state->lirc_prog); 01274 ret=-1; 01275 } 01276 else 01277 { 01278 lirc_parse_string(state,token2,filestack->name,filestack->line); 01279 new_list->string=token2; 01280 new_list->next=NULL; 01281 if(new_entry->config==NULL) 01282 { 01283 new_entry->config=new_list; 01284 } 01285 else 01286 { 01287 new_entry->next_config->next 01288 =new_list; 01289 } 01290 new_entry->next_config=new_list; 01291 } 01292 } 01293 else if(strcasecmp(token,"mode")==0) 01294 { 01295 if(new_entry->change_mode!=NULL) free(new_entry->change_mode); 01296 new_entry->change_mode=token2; 01297 } 01298 else if(strcasecmp(token,"flags")==0) 01299 { 01300 new_entry->flags=lirc_flags(state, token2); 01301 free(token2); 01302 } 01303 else 01304 { 01305 free(token2); 01306 lirc_printf(state, "%s: unknown token \"%s\" in %s:%d ignored\n", 01307 state->lirc_prog,token,filestack->name,filestack->line); 01308 } 01309 } 01310 } 01311 free(string); 01312 if(ret==-1) break; 01313 } 01314 if(remote!=LIRC_ALL) 01315 free(remote); 01316 if(new_entry!=NULL) 01317 { 01318 if(ret==0) 01319 { 01320 ret=lirc_mode(state, "end",NULL,&mode,&new_entry, 01321 &first,&last,check,"",0); 01322 lirc_printf(state, "%s: warning: end token missing at end " 01323 "of file\n",state->lirc_prog); 01324 } 01325 else 01326 { 01327 lirc_freeconfigentries(new_entry); 01328 new_entry=NULL; 01329 } 01330 } 01331 if(mode!=NULL) 01332 { 01333 if(ret==0) 01334 { 01335 lirc_printf(state, "%s: warning: no end token found for mode " 01336 "\"%s\"\n",state->lirc_prog,mode); 01337 } 01338 free(mode); 01339 } 01340 if(ret==0) 01341 { 01342 char *startupmode; 01343 01344 *config=(struct lirc_config *) 01345 malloc(sizeof(struct lirc_config)); 01346 if(*config==NULL) 01347 { 01348 lirc_printf(state, "%s: out of memory\n",state->lirc_prog); 01349 lirc_freeconfigentries(first); 01350 return(-1); 01351 } 01352 (*config)->first=first; 01353 (*config)->next=first; 01354 startupmode = lirc_startupmode(state, (*config)->first); 01355 (*config)->current_mode=startupmode ? strdup(startupmode):NULL; 01356 (*config)->sockfd=-1; 01357 if(full_name != NULL) 01358 { 01359 *full_name = save_full_name; 01360 save_full_name = NULL; 01361 } 01362 } 01363 else 01364 { 01365 *config=NULL; 01366 lirc_freeconfigentries(first); 01367 if(sha_bang && *sha_bang!=NULL) 01368 { 01369 free(*sha_bang); 01370 *sha_bang=NULL; 01371 } 01372 } 01373 if(filestack) 01374 { 01375 stack_free(filestack); 01376 } 01377 if(save_full_name) 01378 { 01379 free(save_full_name); 01380 } 01381 return(ret); 01382 } 01383 01384 static char *lirc_startupmode(const struct lirc_state *state, struct lirc_config_entry *first) 01385 { 01386 struct lirc_config_entry *scan; 01387 char *startupmode; 01388 01389 startupmode=NULL; 01390 scan=first; 01391 /* Set a startup mode based on flags=startup_mode */ 01392 while(scan!=NULL) 01393 { 01394 if(scan->flags&startup_mode) { 01395 if(scan->change_mode!=NULL) { 01396 startupmode=scan->change_mode; 01397 /* Remove the startup mode or it confuses lirc mode system */ 01398 scan->change_mode=NULL; 01399 break; 01400 } 01401 else { 01402 lirc_printf(state, "%s: startup_mode flags requires 'mode ='\n", 01403 state->lirc_prog); 01404 } 01405 } 01406 scan=scan->next; 01407 } 01408 01409 /* Set a default mode if we find a mode = client app name */ 01410 if(startupmode==NULL) { 01411 scan=first; 01412 while(scan!=NULL) 01413 { 01414 if(scan->mode!=NULL && strcasecmp(state->lirc_prog,scan->mode)==0) 01415 { 01416 startupmode=state->lirc_prog; 01417 break; 01418 } 01419 scan=scan->next; 01420 } 01421 } 01422 01423 if(startupmode==NULL) return(NULL); 01424 scan=first; 01425 while(scan!=NULL) 01426 { 01427 if(scan->change_mode!=NULL && scan->flags&once && 01428 strcasecmp(startupmode,scan->change_mode)==0) 01429 { 01430 scan->flags|=ecno; 01431 } 01432 scan=scan->next; 01433 } 01434 return(startupmode); 01435 } 01436 01437 void lirc_freeconfig(struct lirc_config *config) 01438 { 01439 if(config!=NULL) 01440 { 01441 if(config->sockfd!=-1) 01442 { 01443 (void) close(config->sockfd); 01444 config->sockfd=-1; 01445 } 01446 lirc_freeconfigentries(config->first); 01447 free(config->current_mode); 01448 free(config); 01449 } 01450 } 01451 01452 static void lirc_freeconfigentries(struct lirc_config_entry *first) 01453 { 01454 struct lirc_config_entry *c,*config_temp; 01455 struct lirc_list *list,*list_temp; 01456 struct lirc_code *code,*code_temp; 01457 01458 c=first; 01459 while(c!=NULL) 01460 { 01461 if(c->prog) free(c->prog); 01462 if(c->change_mode) free(c->change_mode); 01463 if(c->mode) free(c->mode); 01464 01465 code=c->code; 01466 while(code!=NULL) 01467 { 01468 if(code->remote!=NULL && code->remote!=LIRC_ALL) 01469 free(code->remote); 01470 if(code->button!=NULL && code->button!=LIRC_ALL) 01471 free(code->button); 01472 code_temp=code->next; 01473 free(code); 01474 code=code_temp; 01475 } 01476 01477 list=c->config; 01478 while(list!=NULL) 01479 { 01480 if(list->string) free(list->string); 01481 list_temp=list->next; 01482 free(list); 01483 list=list_temp; 01484 } 01485 config_temp=c->next; 01486 free(c); 01487 c=config_temp; 01488 } 01489 } 01490 01491 static void lirc_clearmode(struct lirc_config *config) 01492 { 01493 struct lirc_config_entry *scan; 01494 01495 if(config->current_mode==NULL) 01496 { 01497 return; 01498 } 01499 scan=config->first; 01500 while(scan!=NULL) 01501 { 01502 if(scan->change_mode!=NULL) 01503 { 01504 if(strcasecmp(scan->change_mode,config->current_mode)==0) 01505 { 01506 scan->flags&=~ecno; 01507 } 01508 } 01509 scan=scan->next; 01510 } 01511 free(config->current_mode); 01512 config->current_mode=NULL; 01513 } 01514 01515 static char *lirc_execute(const struct lirc_state *state, 01516 struct lirc_config *config, 01517 struct lirc_config_entry *scan) 01518 { 01519 char *s; 01520 int do_once=1; 01521 01522 if(scan->flags&mode) 01523 { 01524 lirc_clearmode(config); 01525 } 01526 if(scan->change_mode!=NULL) 01527 { 01528 free(config->current_mode); 01529 config->current_mode=strdup(scan->change_mode); 01530 if(scan->flags&once) 01531 { 01532 if(scan->flags&ecno) 01533 { 01534 do_once=0; 01535 } 01536 else 01537 { 01538 scan->flags|=ecno; 01539 } 01540 } 01541 } 01542 if(scan->next_config!=NULL && 01543 scan->prog!=NULL && 01544 (state->lirc_prog == NULL || strcasecmp(scan->prog,state->lirc_prog)==0) && 01545 do_once==1) 01546 { 01547 s=scan->next_config->string; 01548 scan->next_config=scan->next_config->next; 01549 if(scan->next_config==NULL) 01550 scan->next_config=scan->config; 01551 return(s); 01552 } 01553 return(NULL); 01554 } 01555 01556 static int lirc_iscode(struct lirc_config_entry *scan, char *remote, 01557 char *button,int rep) 01558 { 01559 struct lirc_code *codes; 01560 01561 /* no remote/button specified */ 01562 if(scan->code==NULL) 01563 { 01564 return rep==0 || 01565 (scan->rep>0 && rep>scan->rep_delay && 01566 ((rep-scan->rep_delay-1)%scan->rep)==0); 01567 } 01568 01569 /* remote/button match? */ 01570 if(scan->next_code->remote==LIRC_ALL || 01571 strcasecmp(scan->next_code->remote,remote)==0) 01572 { 01573 if(scan->next_code->button==LIRC_ALL || 01574 strcasecmp(scan->next_code->button,button)==0) 01575 { 01576 int iscode=0; 01577 /* button sequence? */ 01578 if(scan->code->next==NULL || rep==0) 01579 { 01580 scan->next_code=scan->next_code->next; 01581 if(scan->code->next != NULL) 01582 { 01583 iscode=1; 01584 } 01585 } 01586 /* sequence completed? */ 01587 if(scan->next_code==NULL) 01588 { 01589 scan->next_code=scan->code; 01590 if(scan->code->next!=NULL || rep==0 || 01591 (scan->rep>0 && rep>scan->rep_delay && 01592 ((rep-scan->rep_delay-1)%scan->rep)==0)) 01593 iscode=2; 01594 } 01595 return iscode; 01596 } 01597 } 01598 01599 if(rep!=0) return(0); 01600 01601 /* handle toggle_reset */ 01602 if(scan->flags & toggle_reset) 01603 { 01604 scan->next_config = scan->config; 01605 } 01606 01607 codes=scan->code; 01608 if(codes==scan->next_code) return(0); 01609 codes=codes->next; 01610 /* rebase code sequence */ 01611 while(codes!=scan->next_code->next) 01612 { 01613 struct lirc_code *prev,*next; 01614 int flag=1; 01615 01616 prev=scan->code; 01617 next=codes; 01618 while(next!=scan->next_code) 01619 { 01620 if(prev->remote==LIRC_ALL || 01621 strcasecmp(prev->remote,next->remote)==0) 01622 { 01623 if(prev->button==LIRC_ALL || 01624 strcasecmp(prev->button,next->button)==0) 01625 { 01626 prev=prev->next; 01627 next=next->next; 01628 } 01629 else 01630 { 01631 flag=0;break; 01632 } 01633 } 01634 else 01635 { 01636 flag=0;break; 01637 } 01638 } 01639 if(flag==1) 01640 { 01641 if(prev->remote==LIRC_ALL || 01642 strcasecmp(prev->remote,remote)==0) 01643 { 01644 if(prev->button==LIRC_ALL || 01645 strcasecmp(prev->button,button)==0) 01646 { 01647 if(rep==0) 01648 { 01649 scan->next_code=prev->next; 01650 return(0); 01651 } 01652 } 01653 } 01654 } 01655 codes=codes->next; 01656 } 01657 scan->next_code=scan->code; 01658 return(0); 01659 } 01660 01661 #if 0 01662 char *lirc_ir2char(const struct lirc_state *state,struct lirc_config *config,char *code) 01663 { 01664 static int warning=1; 01665 char *string; 01666 01667 if(warning) 01668 { 01669 fprintf(stderr,"%s: warning: lirc_ir2char() is obsolete\n", 01670 state->lirc_prog); 01671 warning=0; 01672 } 01673 if(lirc_code2char(state,config,code,&string)==-1) return(NULL); 01674 return(string); 01675 } 01676 #endif 01677 01678 int lirc_code2char(const struct lirc_state *state, struct lirc_config *config,char *code,char **string) 01679 { 01680 if(config->sockfd!=-1) 01681 { 01682 char command[10+strlen(code)+1+1]; 01683 static char buf[LIRC_PACKET_SIZE]; 01684 size_t buf_len = LIRC_PACKET_SIZE; 01685 int success; 01686 int ret; 01687 01688 sprintf(command, "CODE %s\n", code); 01689 01690 ret = lirc_send_command(state, config->sockfd, command, 01691 buf, &buf_len, &success); 01692 if(success == LIRC_RET_SUCCESS) 01693 { 01694 if(ret > 0) 01695 { 01696 *string = buf; 01697 } 01698 else 01699 { 01700 *string = NULL; 01701 } 01702 return LIRC_RET_SUCCESS; 01703 } 01704 return LIRC_RET_ERROR; 01705 } 01706 return lirc_code2char_internal(state, config, code, string, NULL); 01707 } 01708 01709 int lirc_code2charprog(struct lirc_state *state,struct lirc_config *config,char *code,char **string, 01710 char **prog) 01711 { 01712 char *backup; 01713 int ret; 01714 01715 backup = state->lirc_prog; 01716 state->lirc_prog = NULL; 01717 01718 ret = lirc_code2char_internal(state,config, code, string, prog); 01719 01720 state->lirc_prog = backup; 01721 return ret; 01722 } 01723 01724 static int lirc_code2char_internal(const struct lirc_state *state, 01725 struct lirc_config *config,char *code, 01726 char **string, char **prog) 01727 { 01728 int rep; 01729 char *backup, *strtok_state = NULL; 01730 char *remote,*button; 01731 char *s=NULL; 01732 struct lirc_config_entry *scan; 01733 int exec_level; 01734 int quit_happened; 01735 01736 *string=NULL; 01737 if(sscanf(code,"%*20x %20x %*5000s %*5000s\n",&rep)==1) 01738 { 01739 backup=strdup(code); 01740 if(backup==NULL) return(-1); 01741 01742 strtok_r(backup," ",&strtok_state); 01743 strtok_r(NULL," ",&strtok_state); 01744 button=strtok_r(NULL," ",&strtok_state); 01745 remote=strtok_r(NULL,"\n",&strtok_state); 01746 01747 if(button==NULL || remote==NULL) 01748 { 01749 free(backup); 01750 return(0); 01751 } 01752 01753 scan=config->next; 01754 quit_happened=0; 01755 while(scan!=NULL) 01756 { 01757 exec_level = lirc_iscode(scan,remote,button,rep); 01758 if(exec_level > 0 && 01759 (scan->mode==NULL || 01760 (scan->mode!=NULL && 01761 config->current_mode!=NULL && 01762 strcasecmp(scan->mode,config->current_mode)==0)) && 01763 quit_happened==0 01764 ) 01765 { 01766 if(exec_level > 1) 01767 { 01768 s=lirc_execute(state,config,scan); 01769 if(s != NULL && prog != NULL) 01770 { 01771 *prog = scan->prog; 01772 } 01773 } 01774 else 01775 { 01776 s = NULL; 01777 } 01778 if(scan->flags&quit) 01779 { 01780 quit_happened=1; 01781 config->next=NULL; 01782 scan=scan->next; 01783 continue; 01784 } 01785 else if(s!=NULL) 01786 { 01787 config->next=scan->next; 01788 break; 01789 } 01790 } 01791 scan=scan->next; 01792 } 01793 free(backup); 01794 if(s!=NULL) 01795 { 01796 *string=s; 01797 return(0); 01798 } 01799 } 01800 config->next=config->first; 01801 return(0); 01802 } 01803 01804 #define PACKET_SIZE 100 01805 01806 #if 0 01807 char *lirc_nextir(struct lirc_state *state) 01808 { 01809 static int warning=1; 01810 char *code; 01811 int ret; 01812 01813 if(warning) 01814 { 01815 fprintf(stderr,"%s: warning: lirc_nextir() is obsolete\n", 01816 state->lirc_prog); 01817 warning=0; 01818 } 01819 ret=lirc_nextcode(state, &code); 01820 if(ret==-1) return(NULL); 01821 return(code); 01822 } 01823 #endif 01824 01825 int lirc_nextcode(struct lirc_state *state, char **code) 01826 { 01827 static int packet_size=PACKET_SIZE; 01828 static int end_len=0; 01829 ssize_t len=0; 01830 char *end,c; 01831 01832 *code=NULL; 01833 if(state->lirc_buffer==NULL) 01834 { 01835 state->lirc_buffer=(char *) malloc(packet_size+1); 01836 if(state->lirc_buffer==NULL) 01837 { 01838 lirc_printf(state, "%s: out of memory\n",state->lirc_prog); 01839 return(-1); 01840 } 01841 state->lirc_buffer[0]=0; 01842 } 01843 while((end=strchr(state->lirc_buffer,'\n'))==NULL) 01844 { 01845 if(end_len>=packet_size) 01846 { 01847 char *new_buffer; 01848 01849 packet_size+=PACKET_SIZE; 01850 new_buffer=(char *) realloc(state->lirc_buffer,packet_size+1); 01851 if(new_buffer==NULL) 01852 { 01853 return(-1); 01854 } 01855 state->lirc_buffer=new_buffer; 01856 } 01857 len=read(state->lirc_lircd,state->lirc_buffer+end_len,packet_size-end_len); 01858 if(len<=0) 01859 { 01860 if(len==-1 && errno==EAGAIN) return(0); 01861 else return(-1); 01862 } 01863 end_len+=len; 01864 state->lirc_buffer[end_len]=0; 01865 /* return if next code not yet available completely */ 01866 if((end=strchr(state->lirc_buffer,'\n'))==NULL) 01867 { 01868 return(0); 01869 } 01870 } 01871 /* copy first line to buffer (code) and move remaining chars to 01872 state->lirc_buffers start */ 01873 end++; 01874 end_len=strlen(end); 01875 c=end[0]; 01876 end[0]=0; 01877 *code=strdup(state->lirc_buffer); 01878 end[0]=c; 01879 memmove(state->lirc_buffer,end,end_len+1); 01880 if(*code==NULL) return(-1); 01881 return(0); 01882 } 01883 01884 size_t lirc_getsocketname(const char *filename, char *buf, size_t size) 01885 { 01886 if(strlen(filename)+2<=size) 01887 { 01888 strcpy(buf, filename); 01889 strcat(buf, "d"); 01890 } 01891 return strlen(filename)+2; 01892 } 01893 01894 const char *lirc_getmode(const struct lirc_state *state, struct lirc_config *config) 01895 { 01896 if(config->sockfd!=-1) 01897 { 01898 static char buf[LIRC_PACKET_SIZE]; 01899 size_t buf_len = LIRC_PACKET_SIZE; 01900 int success; 01901 int ret; 01902 01903 ret = lirc_send_command(state, config->sockfd, "GETMODE\n", 01904 buf, &buf_len, &success); 01905 if(success == LIRC_RET_SUCCESS) 01906 { 01907 if(ret > 0) 01908 { 01909 return buf; 01910 } 01911 else 01912 { 01913 return NULL; 01914 } 01915 } 01916 return NULL; 01917 } 01918 return config->current_mode; 01919 } 01920 01921 const char *lirc_setmode(const struct lirc_state *state, struct lirc_config *config, const char *mode) 01922 { 01923 if(config->sockfd!=-1) 01924 { 01925 static char buf[LIRC_PACKET_SIZE]; 01926 size_t buf_len = LIRC_PACKET_SIZE; 01927 int success; 01928 int ret; 01929 char cmd[LIRC_PACKET_SIZE]; 01930 if(snprintf(cmd, LIRC_PACKET_SIZE, "SETMODE%s%s\n", 01931 mode ? " ":"", 01932 mode ? mode:"") 01933 >= LIRC_PACKET_SIZE) 01934 { 01935 return NULL; 01936 } 01937 01938 ret = lirc_send_command(state, config->sockfd, cmd, 01939 buf, &buf_len, &success); 01940 if(success == LIRC_RET_SUCCESS) 01941 { 01942 if(ret > 0) 01943 { 01944 return buf; 01945 } 01946 else 01947 { 01948 return NULL; 01949 } 01950 } 01951 return NULL; 01952 } 01953 01954 free(config->current_mode); 01955 config->current_mode = mode ? strdup(mode) : NULL; 01956 return config->current_mode; 01957 } 01958 01959 static const char *lirc_read_string(const struct lirc_state *state, int fd) 01960 { 01961 static char buffer[LIRC_PACKET_SIZE+1]=""; 01962 char *end; 01963 static int head=0, tail=0; 01964 int ret; 01965 ssize_t n; 01966 fd_set fds; 01967 struct timeval tv; 01968 01969 if(head>0) 01970 { 01971 memmove(buffer,buffer+head,tail-head+1); 01972 tail-=head; 01973 head=0; 01974 end=strchr(buffer,'\n'); 01975 } 01976 else 01977 { 01978 end=NULL; 01979 } 01980 if(strlen(buffer)!=tail) 01981 { 01982 lirc_printf(state, "%s: protocol error\n", state->lirc_prog); 01983 goto lirc_read_string_error; 01984 } 01985 01986 while(end==NULL) 01987 { 01988 if(LIRC_PACKET_SIZE<=tail) 01989 { 01990 lirc_printf(state, "%s: bad packet\n", state->lirc_prog); 01991 goto lirc_read_string_error; 01992 } 01993 01994 FD_ZERO(&fds); 01995 FD_SET(fd,&fds); 01996 tv.tv_sec=LIRC_TIMEOUT; 01997 tv.tv_usec=0; 01998 do 01999 { 02000 ret=select(fd+1,&fds,NULL,NULL,&tv); 02001 } 02002 while(ret==-1 && errno==EINTR); 02003 if(ret==-1) 02004 { 02005 lirc_printf(state, "%s: select() failed\n", state->lirc_prog); 02006 lirc_perror(state, state->lirc_prog); 02007 goto lirc_read_string_error; 02008 } 02009 else if(ret==0) 02010 { 02011 lirc_printf(state, "%s: timeout\n", state->lirc_prog); 02012 goto lirc_read_string_error; 02013 } 02014 02015 n=read(fd, buffer+tail, LIRC_PACKET_SIZE-tail); 02016 if(n<=0) 02017 { 02018 lirc_printf(state, "%s: read() failed\n", state->lirc_prog); 02019 lirc_perror(state, state->lirc_prog); 02020 goto lirc_read_string_error; 02021 } 02022 buffer[tail+n]=0; 02023 tail+=n; 02024 end=strchr(buffer,'\n'); 02025 } 02026 02027 end[0]=0; 02028 head=strlen(buffer)+1; 02029 return(buffer); 02030 02031 lirc_read_string_error: 02032 head=tail=0; 02033 buffer[0]=0; 02034 return(NULL); 02035 } 02036 02037 int lirc_send_command(const struct lirc_state *lstate, int sockfd, const char *command, char *buf, size_t *buf_len, int *ret_status) 02038 { 02039 int done,todo; 02040 const char *string,*data; 02041 char *endptr; 02042 enum packet_state state; 02043 int status,n; 02044 unsigned long data_n=0; 02045 size_t written=0, max=0, len; 02046 02047 if(buf_len!=NULL) 02048 { 02049 max=*buf_len; 02050 } 02051 todo=strlen(command); 02052 data=command; 02053 while(todo>0) 02054 { 02055 done=write(sockfd,(const void *) data,todo); 02056 if(done<0) 02057 { 02058 lirc_printf(lstate, "%s: could not send packet\n", 02059 lstate->lirc_prog); 02060 lirc_perror(lstate, lstate->lirc_prog); 02061 return(-1); 02062 } 02063 data+=done; 02064 todo-=done; 02065 } 02066 02067 /* get response */ 02068 status=LIRC_RET_SUCCESS; 02069 state=P_BEGIN; 02070 n=0; 02071 while(1) 02072 { 02073 string=lirc_read_string(lstate, sockfd); 02074 if(string==NULL) return(-1); 02075 switch(state) 02076 { 02077 case P_BEGIN: 02078 if(strcasecmp(string,"BEGIN")!=0) 02079 { 02080 continue; 02081 } 02082 state=P_MESSAGE; 02083 break; 02084 case P_MESSAGE: 02085 if(strncasecmp(string,command,strlen(string))!=0 || 02086 strlen(string)+1!=strlen(command)) 02087 { 02088 state=P_BEGIN; 02089 continue; 02090 } 02091 state=P_STATUS; 02092 break; 02093 case P_STATUS: 02094 if(strcasecmp(string,"SUCCESS")==0) 02095 { 02096 status=LIRC_RET_SUCCESS; 02097 } 02098 else if(strcasecmp(string,"END")==0) 02099 { 02100 status=LIRC_RET_SUCCESS; 02101 goto good_packet; 02102 } 02103 else if(strcasecmp(string,"ERROR")==0) 02104 { 02105 lirc_printf(lstate, "%s: command failed: %s", 02106 lstate->lirc_prog, command); 02107 status=LIRC_RET_ERROR; 02108 } 02109 else 02110 { 02111 goto bad_packet; 02112 } 02113 state=P_DATA; 02114 break; 02115 case P_DATA: 02116 if(strcasecmp(string,"END")==0) 02117 { 02118 goto good_packet; 02119 } 02120 else if(strcasecmp(string,"DATA")==0) 02121 { 02122 state=P_N; 02123 break; 02124 } 02125 goto bad_packet; 02126 case P_N: 02127 errno=0; 02128 data_n=strtoul(string,&endptr,0); 02129 if(!*string || *endptr) 02130 { 02131 goto bad_packet; 02132 } 02133 if(data_n==0) 02134 { 02135 state=P_END; 02136 } 02137 else 02138 { 02139 state=P_DATA_N; 02140 } 02141 break; 02142 case P_DATA_N: 02143 len=strlen(string); 02144 if(buf!=NULL && written+len+1<max) 02145 { 02146 memcpy(buf+written, string, len+1); 02147 } 02148 written+=len+1; 02149 n++; 02150 if(n==data_n) state=P_END; 02151 break; 02152 case P_END: 02153 if(strcasecmp(string,"END")==0) 02154 { 02155 goto good_packet; 02156 } 02157 goto bad_packet; 02158 break; 02159 } 02160 } 02161 02162 /* never reached */ 02163 02164 bad_packet: 02165 lirc_printf(lstate, "%s: bad return packet\n", lstate->lirc_prog); 02166 return(-1); 02167 02168 good_packet: 02169 if(ret_status!=NULL) 02170 { 02171 *ret_status=status; 02172 } 02173 if(buf_len!=NULL) 02174 { 02175 *buf_len=written; 02176 } 02177 return (int) data_n; 02178 } 02179 02180 int lirc_identify(const struct lirc_state *state, int sockfd) 02181 { 02182 char command[10+strlen(state->lirc_prog)+1+1]; 02183 int success; 02184 02185 sprintf(command, "IDENT %s\n", state->lirc_prog); 02186 02187 (void) lirc_send_command(state, sockfd, command, NULL, NULL, &success); 02188 return success; 02189 }
1.7.6.1
