Pileus Git - ~andy/fetchmail/blob - rcfile_y.y

   1 %{
   2 /*
   3  * rcfile_y.y -- Run control file parser for fetchmail
   4  *
   5  * For license terms, see the file COPYING in this directory.
   6  */
   7
   8 #include "config.h"
   9 #include <stdio.h>
  10 #include <sys/types.h>
  11 #include <sys/file.h>
  12 #if defined(HAVE_SYS_WAIT_H)
  13 #include <sys/wait.h>
  14 #endif
  15 #include <sys/stat.h>
  16 #include <errno.h>
  17 #if defined(STDC_HEADERS)
  18 #include <stdlib.h>
  19 #endif
  20 #if defined(HAVE_UNISTD_H)
  21 #include <unistd.h>
  22 #endif
  23 #include <string.h>
  24
  25 #if NET_SECURITY
  26 #include <net/security.h>
  27 #endif /* NET_SECURITY */
  28
  29 #include "fetchmail.h"
  30
  31 /* parser reads these */
  32 char *rcfile;                   /* path name of rc file */
  33 struct query cmd_opts;          /* where to put command-line info */
  34
  35 /* parser sets these */
  36 struct query *querylist;        /* head of server list (globally visible) */
  37
  38 int yydebug;                    /* in case we didn't generate with -- debug */
  39
  40 static struct query current;    /* current server record */
  41 static int prc_errflag;
  42 static struct hostdata *leadentry;
  43 static flag trailer;
  44
  45 static void record_current();
  46 static void user_reset();
  47 static void reset_server(char *name, int skip);
  48
  49 /* using Bison, this arranges that yydebug messages will show actual tokens */
  50 extern char * yytext;
  51 #define YYPRINT(fp, type, val)  fprintf(fp, " = \"%s\"", yytext)
  52 %}
  53
  54 %union {
  55   int proto;
  56   int number;
  57   char *sval;
  58 }
  59
  60 %token DEFAULTS POLL SKIP VIA AKA LOCALDOMAINS PROTOCOL
  61 %token AUTHENTICATE TIMEOUT KPOP KERBEROS4 KERBEROS5 KERBEROS
  62 %token ENVELOPE QVIRTUAL USERNAME PASSWORD FOLDER SMTPHOST MDA SMTPADDRESS
  63 %token SPAMRESPONSE PRECONNECT POSTCONNECT LIMIT
  64 %token NETSEC INTERFACE MONITOR
  65 %token IS HERE THERE TO MAP WILDCARD
  66 %token BATCHLIMIT FETCHLIMIT EXPUNGE
  67 %token SET LOGFILE DAEMON SYSLOG IDFILE INVISIBLE POSTMASTER
  68 %token <proto> PROTO
  69 %token <sval>  STRING
  70 %token <number> NUMBER
  71 %token NO KEEP FLUSH FETCHALL REWRITE FORCECR STRIPCR PASS8BITS DROPSTATUS
  72 %token DNS SERVICE PORT UIDL INTERVAL MIMEDECODE CHECKALIAS
  73
  74 %%
  75
  76 rcfile          : /* empty */
  77                 | statement_list
  78                 ;
  79
  80 statement_list  : statement
  81                 | statement_list statement
  82                 ;
  83
  84 optmap          : MAP | /* EMPTY */;
  85
  86 /* future global options should also have the form SET <name> optmap <value> */
  87 statement       : SET LOGFILE optmap STRING     {run.logfile = xstrdup($4);}
  88                 | SET IDFILE optmap STRING      {run.idfile = xstrdup($4);}
  89                 | SET DAEMON optmap NUMBER      {run.poll_interval = $4;}
  90                 | SET POSTMASTER optmap STRING  {run.postmaster = xstrdup($4);}
  91                 | SET SYSLOG                    {run.use_syslog = TRUE;}
  92                 | SET INVISIBLE                 {run.invisible = TRUE;}
  93
  94 /*
  95  * The way the next two productions are written depends on the fact that
  96  * userspecs cannot be empty.  It's a kluge to deal with files that set
  97  * up a load of defaults and then have poll statements following with no
  98  * user options at all.
  99  */
 100                 | define_server serverspecs             {record_current();}
 101                 | define_server serverspecs userspecs
 102
 103 /* detect and complain about the most common user error */
 104                 | define_server serverspecs userspecs serv_option
 105                         {yyerror("server option after user options");}
 106                 ;
 107
 108 define_server   : POLL STRING           {reset_server($2, FALSE);}
 109                 | SKIP STRING           {reset_server($2, TRUE);}
 110                 | DEFAULTS              {reset_server("defaults", FALSE);}
 111                 ;
 112
 113 serverspecs     : /* EMPTY */
 114                 | serverspecs serv_option
 115                 ;
 116
 117 alias_list      : STRING                {save_str(&current.server.akalist,$1,0);}
 118                 | alias_list STRING     {save_str(&current.server.akalist,$2,0);}
 119                 ;
 120
 121 domain_list     : STRING                {save_str(&current.server.localdomains,$1,0);}
 122                 | domain_list STRING    {save_str(&current.server.localdomains,$2,0);}
 123                 ;
 124
 125 serv_option     : AKA alias_list
 126                 | VIA STRING            {current.server.via = xstrdup($2);}
 127                 | LOCALDOMAINS domain_list
 128                 | PROTOCOL PROTO        {current.server.protocol = $2;}
 129                 | PROTOCOL KPOP         {
 130                                             current.server.protocol = P_POP3;
 131 #ifdef KERBEROS_V5
 132                                             current.server.preauthenticate = A_KERBEROS_V5;
 133 #else
 134                                             current.server.preauthenticate = A_KERBEROS_V4;
 135 #endif /* KERBEROS_V5 */
 136 #if INET6
 137                                             current.server.service = KPOP_PORT;
 138 #else /* INET6 */
 139                                             current.server.port = KPOP_PORT;
 140 #endif /* INET6 */
 141                                         }
 142                 | UIDL                  {current.server.uidl = FLAG_TRUE;}
 143                 | NO UIDL               {current.server.uidl  = FLAG_FALSE;}
 144                 | CHECKALIAS            {current.server.checkalias = FLAG_TRUE;}
 145                 | NO CHECKALIAS         {current.server.checkalias  = FLAG_FALSE;}
 146                 | SERVICE STRING        {
 147 #if INET6
 148                                         current.server.service = $2;
 149 #endif /* INET6 */
 150                                         }
 151                 | PORT NUMBER           {
 152 #if !INET6
 153                                         current.server.port = $2;
 154 #endif /* !INET6 */
 155                                         }
 156                 | INTERVAL NUMBER               {current.server.interval = $2;}
 157                 | AUTHENTICATE PASSWORD {current.server.preauthenticate = A_PASSWORD;}
 158                 | AUTHENTICATE KERBEROS4        {current.server.preauthenticate = A_KERBEROS_V4;}
 159                 | AUTHENTICATE KERBEROS5        {current.server.preauthenticate = A_KERBEROS_V5;}
 160                 | AUTHENTICATE KERBEROS         {
 161 #ifdef KERBEROS_V5
 162                     current.server.preauthenticate = A_KERBEROS_V5;
 163 #else
 164                     current.server.preauthenticate = A_KERBEROS_V4;
 165 #endif /* KERBEROS_V5 */
 166                 }
 167                 | TIMEOUT NUMBER        {current.server.timeout = $2;}
 168
 169                 | ENVELOPE NUMBER STRING
 170                                         {
 171                                             current.server.envelope =
 172                                                 xstrdup($3);
 173                                             current.server.envskip = $2;
 174                                         }
 175                 | ENVELOPE STRING
 176                                         {
 177                                             current.server.envelope =
 178                                                 xstrdup($2);
 179                                             current.server.envskip = 0;
 180                                         }
 181
 182                 | QVIRTUAL STRING       {current.server.qvirtual=xstrdup($2);}
 183                 | NETSEC STRING         {
 184 #ifdef NET_SECURITY
 185                                             void *request;
 186                                             int requestlen;
 187
 188                                             if (net_security_strtorequest($2, &request, &requestlen))
 189                                                 yyerror("invalid security request");
 190                                             else {
 191                                                 current.server.netsec = xstrdup($2);
 192                                                 free(request);
 193                                             }
 194 #else
 195                                             yyerror("network-security support disabled");
 196 #endif /* NET_SECURITY */
 197                                         }
 198                 | INTERFACE STRING      {
 199 #if defined(linux) && !defined(INET6)
 200                                         interface_parse($2, &current.server);
 201 #else /* defined(linux) && !defined(INET6) */
 202                                         fprintf(stderr, "fetchmail: interface option is only supported under Linux\n");
 203 #endif /* defined(linux) && !defined(INET6) */
 204                                         }
 205                 | MONITOR STRING        {
 206 #if defined(linux) && !defined(INET6)
 207                                         current.server.monitor = xstrdup($2);
 208 #else /* defined(linux) && !defined(INET6) */
 209                                         fprintf(stderr, "fetchmail: monitor option is only supported under Linux\n");
 210 #endif /* defined(linux) && !defined(INET6) */
 211                                         }
 212                 | DNS                   {current.server.dns = FLAG_TRUE;}
 213                 | NO DNS                {current.server.dns = FLAG_FALSE;}
 214                 | NO ENVELOPE           {current.server.envelope = STRING_DISABLED;}
 215                 ;
 216
 217 userspecs       : user1opts             {record_current(); user_reset();}
 218                 | explicits
 219                 ;
 220
 221 explicits       : explicitdef           {record_current(); user_reset();}
 222                 | explicits explicitdef {record_current(); user_reset();}
 223                 ;
 224
 225 explicitdef     : userdef user0opts
 226                 ;
 227
 228 userdef         : USERNAME STRING       {current.remotename = xstrdup($2);}
 229                 | USERNAME mapping_list HERE
 230                 | USERNAME STRING THERE {current.remotename = xstrdup($2);}
 231                 ;
 232
 233 user0opts       : /* EMPTY */
 234                 | user0opts user_option
 235                 ;
 236
 237 user1opts       : user_option
 238                 | user1opts user_option
 239                 ;
 240
 241 localnames      : WILDCARD              {current.wildcard =  TRUE;}
 242                 | mapping_list          {current.wildcard =  FALSE;}
 243                 | mapping_list WILDCARD {current.wildcard =  TRUE;}
 244                 ;
 245
 246 mapping_list    : mapping
 247                 | mapping_list mapping
 248                 ;
 249
 250 mapping         : STRING
 251                                 {save_str_pair(&current.localnames, $1, NULL);}
 252                 | STRING MAP STRING
 253                                 {save_str_pair(&current.localnames, $1, $3);}
 254                 ;
 255
 256 folder_list     : STRING                {save_str(&current.mailboxes,$1,0);}
 257                 | folder_list STRING    {save_str(&current.mailboxes,$2,0);}
 258                 ;
 259
 260 smtp_list       : STRING                {save_str(&current.smtphunt, $1,TRUE);}
 261                 | smtp_list STRING      {save_str(&current.smtphunt, $2,TRUE);}
 262                 ;
 263
 264 num_list        : NUMBER
 265                         {
 266                             struct idlist *id;
 267                             id=save_str(&current.antispam,STRING_DUMMY,0);
 268                             id->val.status.num = $1;
 269                         }
 270                 | num_list NUMBER
 271                         {
 272                             struct idlist *id;
 273                             id=save_str(&current.antispam,STRING_DUMMY,0);
 274                             id->val.status.num = $2;
 275                         }
 276                 ;
 277
 278 user_option     : TO localnames HERE
 279                 | TO localnames
 280                 | IS localnames HERE
 281                 | IS localnames
 282
 283                 | IS STRING THERE       {current.remotename = xstrdup($2);}
 284                 | PASSWORD STRING       {current.password   = xstrdup($2);}
 285                 | FOLDER folder_list
 286                 | SMTPHOST smtp_list
 287                 | SMTPADDRESS STRING    {current.smtpaddress = xstrdup($2);}
 288                 | SPAMRESPONSE num_list
 289                 | MDA STRING            {current.mda        = xstrdup($2);}
 290                 | PRECONNECT STRING     {current.preconnect = xstrdup($2);}
 291                 | POSTCONNECT STRING    {current.postconnect = xstrdup($2);}
 292
 293                 | KEEP                  {current.keep       = FLAG_TRUE;}
 294                 | FLUSH                 {current.flush      = FLAG_TRUE;}
 295                 | FETCHALL              {current.fetchall   = FLAG_TRUE;}
 296                 | REWRITE               {current.rewrite    = FLAG_TRUE;}
 297                 | FORCECR               {current.forcecr    = FLAG_TRUE;}
 298                 | STRIPCR               {current.stripcr    = FLAG_TRUE;}
 299                 | PASS8BITS             {current.pass8bits  = FLAG_TRUE;}
 300                 | DROPSTATUS            {current.dropstatus = FLAG_TRUE;}
 301                 | MIMEDECODE            {current.mimedecode = FLAG_TRUE;}
 302
 303                 | NO KEEP               {current.keep       = FLAG_FALSE;}
 304                 | NO FLUSH              {current.flush      = FLAG_FALSE;}
 305                 | NO FETCHALL           {current.fetchall   = FLAG_FALSE;}
 306                 | NO REWRITE            {current.rewrite    = FLAG_FALSE;}
 307                 | NO FORCECR            {current.forcecr    = FLAG_FALSE;}
 308                 | NO STRIPCR            {current.stripcr    = FLAG_FALSE;}
 309                 | NO PASS8BITS          {current.pass8bits  = FLAG_FALSE;}
 310                 | NO DROPSTATUS         {current.dropstatus = FLAG_FALSE;}
 311                 | NO MIMEDECODE         {current.mimedecode = FLAG_FALSE;}
 312
 313                 | LIMIT NUMBER          {current.limit      = NUM_VALUE($2);}
 314                 | FETCHLIMIT NUMBER     {current.fetchlimit = NUM_VALUE($2);}
 315                 | BATCHLIMIT NUMBER     {current.batchlimit = NUM_VALUE($2);}
 316                 | EXPUNGE NUMBER        {current.expunge    = NUM_VALUE($2);}
 317                 ;
 318 %%
 319
 320 /* lexer interface */
 321 extern char *rcfile;
 322 extern int prc_lineno;
 323 extern char *yytext;
 324 extern FILE *yyin;
 325
 326 static struct query *hosttail;  /* where to add new elements */
 327
 328 void yyerror (const char *s)
 329 /* report a syntax error */
 330 {
 331     error_at_line( 0, 0, rcfile, prc_lineno, "%s at %s", s,
 332                    (yytext && yytext[0]) ? yytext : "end of input");
 333     prc_errflag++;
 334 }
 335
 336 int prc_filecheck(pathname, securecheck)
 337 /* check that a configuration file is secure */
 338 const char *pathname;           /* pathname for the configuration file */
 339 const flag securecheck;
 340 {
 341 #ifndef __EMX__
 342     struct stat statbuf;
 343
 344     errno = 0;
 345
 346     /* special cases useful for debugging purposes */
 347     if (strcmp("/dev/null", pathname) == 0)
 348         return(PS_SUCCESS);
 349
 350     /* the run control file must have the same uid as the REAL uid of this
 351        process, it must have permissions no greater than 600, and it must not
 352        be a symbolic link.  We check these conditions here. */
 353
 354     if (lstat(pathname, &statbuf) < 0) {
 355         if (errno == ENOENT)
 356             return(PS_SUCCESS);
 357         else {
 358             error(0, errno, "lstat: %s", pathname);
 359             return(PS_IOERR);
 360         }
 361     }
 362
 363     if (!securecheck)   return 0;
 364
 365     if ((statbuf.st_mode & S_IFLNK) == S_IFLNK)
 366     {
 367         fprintf(stderr, "File %s must not be a symbolic link.\n", pathname);
 368         return(PS_AUTHFAIL);
 369     }
 370
 371     if (statbuf.st_mode & ~(S_IFREG | S_IREAD | S_IWRITE | S_IEXEC | S_IXGRP))
 372     {
 373         fprintf(stderr, "File %s must have no more than -rwx--x--- (0710) permissions.\n",
 374                 pathname);
 375         return(PS_AUTHFAIL);
 376     }
 377
 378     if (statbuf.st_uid != getuid())
 379     {
 380         fprintf(stderr, "File %s must be owned by you.\n", pathname);
 381         return(PS_AUTHFAIL);
 382     }
 383 #endif
 384     return(PS_SUCCESS);
 385 }
 386
 387 int prc_parse_file (const char *pathname, const flag securecheck)
 388 /* digest the configuration into a linked list of host records */
 389 {
 390     prc_errflag = 0;
 391     querylist = hosttail = (struct query *)NULL;
 392
 393     errno = 0;
 394
 395     /* Check that the file is secure */
 396     if ( (prc_errflag = prc_filecheck(pathname, securecheck)) != 0 )
 397         return(prc_errflag);
 398
 399     if (errno == ENOENT)
 400         return(PS_SUCCESS);
 401
 402     /* Open the configuration and feed it to the lexer. */
 403     if ((yyin = fopen(pathname,"r")) == (FILE *)NULL) {
 404         error(0, errno, "open: %s", pathname);
 405         return(PS_IOERR);
 406     }
 407
 408     yyparse();          /* parse entire file */
 409
 410     fclose(yyin);
 411
 412     if (prc_errflag)
 413         return(PS_SYNTAX);
 414     else
 415         return(PS_SUCCESS);
 416 }
 417
 418 static void reset_server(char *name, int skip)
 419 /* clear the entire global record and initialize it with a new name */
 420 {
 421     trailer = FALSE;
 422     memset(&current,'\0',sizeof(current));
 423     current.smtp_socket = -1;
 424     current.server.pollname = xstrdup(name);
 425     current.server.skip = skip;
 426 }
 427
 428
 429 static void user_reset(void)
 430 /* clear the global current record (user parameters) used by the parser */
 431 {
 432     struct hostdata save;
 433
 434     /*
 435      * Purpose of this code is to initialize the new server block, but
 436      * preserve whatever server name was previously set.  Also
 437      * preserve server options unless the command-line explicitly
 438      * overrides them.
 439      */
 440     save = current.server;
 441
 442     memset(&current, '\0', sizeof(current));
 443     current.smtp_socket = -1;
 444
 445     current.server = save;
 446 }
 447
 448 struct query *hostalloc(init)
 449 /* append a host record to the host list */
 450 struct query *init;     /* pointer to block containing initial values */
 451 {
 452     struct query *node;
 453
 454     /* allocate new node */
 455     node = (struct query *) xmalloc(sizeof(struct query));
 456
 457     /* initialize it */
 458     if (init)
 459         memcpy(node, init, sizeof(struct query));
 460     else
 461     {
 462         memset(node, '\0', sizeof(struct query));
 463         node->smtp_socket = -1;
 464     }
 465
 466     /* append to end of list */
 467     if (hosttail != (struct query *) 0)
 468         hosttail->next = node;  /* list contains at least one element */
 469     else
 470         querylist = node;       /* list is empty */
 471     hosttail = node;
 472
 473     if (trailer)
 474         node->server.lead_server = leadentry;
 475     else
 476     {
 477         node->server.lead_server = NULL;
 478         leadentry = &node->server;
 479     }
 480
 481     return(node);
 482 }
 483
 484 static void record_current(void)
 485 /* register current parameters and append to the host list */
 486 {
 487     (void) hostalloc(&current);
 488     trailer = TRUE;
 489 }
 490
 491 /* easier to do this than cope with variations in where the library lives */
 492 int yywrap(void) {return 1;}
 493
 494 /* rcfile_y.y ends here */
 495
 496