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 user_option     : TO localnames HERE
 265                 | TO localnames
 266                 | IS localnames HERE
 267                 | IS localnames
 268
 269                 | IS STRING THERE       {current.remotename = xstrdup($2);}
 270                 | PASSWORD STRING       {current.password   = xstrdup($2);}
 271                 | FOLDER folder_list
 272                 | SMTPHOST smtp_list
 273                 | SMTPADDRESS STRING    {current.smtpaddress = xstrdup($2);}
 274                 | SPAMRESPONSE NUMBER   {current.antispam = $2;}
 275                 | MDA STRING            {current.mda        = xstrdup($2);}
 276                 | PRECONNECT STRING     {current.preconnect = xstrdup($2);}
 277                 | POSTCONNECT STRING    {current.postconnect = xstrdup($2);}
 278
 279                 | KEEP                  {current.keep       = FLAG_TRUE;}
 280                 | FLUSH                 {current.flush      = FLAG_TRUE;}
 281                 | FETCHALL              {current.fetchall   = FLAG_TRUE;}
 282                 | REWRITE               {current.rewrite    = FLAG_TRUE;}
 283                 | FORCECR               {current.forcecr    = FLAG_TRUE;}
 284                 | STRIPCR               {current.stripcr    = FLAG_TRUE;}
 285                 | PASS8BITS             {current.pass8bits  = FLAG_TRUE;}
 286                 | DROPSTATUS            {current.dropstatus = FLAG_TRUE;}
 287                 | MIMEDECODE            {current.mimedecode = FLAG_TRUE;}
 288
 289                 | NO KEEP               {current.keep       = FLAG_FALSE;}
 290                 | NO FLUSH              {current.flush      = FLAG_FALSE;}
 291                 | NO FETCHALL           {current.fetchall   = FLAG_FALSE;}
 292                 | NO REWRITE            {current.rewrite    = FLAG_FALSE;}
 293                 | NO FORCECR            {current.forcecr    = FLAG_FALSE;}
 294                 | NO STRIPCR            {current.stripcr    = FLAG_FALSE;}
 295                 | NO PASS8BITS          {current.pass8bits  = FLAG_FALSE;}
 296                 | NO DROPSTATUS         {current.dropstatus = FLAG_FALSE;}
 297                 | NO MIMEDECODE         {current.mimedecode = FLAG_FALSE;}
 298
 299                 | LIMIT NUMBER          {current.limit      = NUM_VALUE($2);}
 300                 | FETCHLIMIT NUMBER     {current.fetchlimit = NUM_VALUE($2);}
 301                 | BATCHLIMIT NUMBER     {current.batchlimit = NUM_VALUE($2);}
 302                 | EXPUNGE NUMBER        {current.expunge    = NUM_VALUE($2);}
 303                 ;
 304 %%
 305
 306 /* lexer interface */
 307 extern char *rcfile;
 308 extern int prc_lineno;
 309 extern char *yytext;
 310 extern FILE *yyin;
 311
 312 static struct query *hosttail;  /* where to add new elements */
 313
 314 void yyerror (const char *s)
 315 /* report a syntax error */
 316 {
 317     error_at_line( 0, 0, rcfile, prc_lineno, "%s at %s", s,
 318                    (yytext && yytext[0]) ? yytext : "end of input");
 319     prc_errflag++;
 320 }
 321
 322 int prc_filecheck(pathname, securecheck)
 323 /* check that a configuration file is secure */
 324 const char *pathname;           /* pathname for the configuration file */
 325 const flag securecheck;
 326 {
 327 #ifndef __EMX__
 328     struct stat statbuf;
 329
 330     errno = 0;
 331
 332     /* special cases useful for debugging purposes */
 333     if (strcmp("/dev/null", pathname) == 0)
 334         return(PS_SUCCESS);
 335
 336     /* the run control file must have the same uid as the REAL uid of this
 337        process, it must have permissions no greater than 600, and it must not
 338        be a symbolic link.  We check these conditions here. */
 339
 340     if (lstat(pathname, &statbuf) < 0) {
 341         if (errno == ENOENT)
 342             return(PS_SUCCESS);
 343         else {
 344             error(0, errno, "lstat: %s", pathname);
 345             return(PS_IOERR);
 346         }
 347     }
 348
 349     if (!securecheck)   return 0;
 350
 351     if ((statbuf.st_mode & S_IFLNK) == S_IFLNK)
 352     {
 353         fprintf(stderr, "File %s must not be a symbolic link.\n", pathname);
 354         return(PS_AUTHFAIL);
 355     }
 356
 357     if (statbuf.st_mode & ~(S_IFREG | S_IREAD | S_IWRITE | S_IEXEC | S_IXGRP))
 358     {
 359         fprintf(stderr, "File %s must have no more than -rwx--x--- (0710) permissions.\n",
 360                 pathname);
 361         return(PS_AUTHFAIL);
 362     }
 363
 364     if (statbuf.st_uid != getuid())
 365     {
 366         fprintf(stderr, "File %s must be owned by you.\n", pathname);
 367         return(PS_AUTHFAIL);
 368     }
 369 #endif
 370     return(PS_SUCCESS);
 371 }
 372
 373 int prc_parse_file (const char *pathname, const flag securecheck)
 374 /* digest the configuration into a linked list of host records */
 375 {
 376     prc_errflag = 0;
 377     querylist = hosttail = (struct query *)NULL;
 378
 379     errno = 0;
 380
 381     /* Check that the file is secure */
 382     if ( (prc_errflag = prc_filecheck(pathname, securecheck)) != 0 )
 383         return(prc_errflag);
 384
 385     if (errno == ENOENT)
 386         return(PS_SUCCESS);
 387
 388     /* Open the configuration and feed it to the lexer. */
 389     if ((yyin = fopen(pathname,"r")) == (FILE *)NULL) {
 390         error(0, errno, "open: %s", pathname);
 391         return(PS_IOERR);
 392     }
 393
 394     yyparse();          /* parse entire file */
 395
 396     fclose(yyin);
 397
 398     if (prc_errflag)
 399         return(PS_SYNTAX);
 400     else
 401         return(PS_SUCCESS);
 402 }
 403
 404 static void reset_server(char *name, int skip)
 405 /* clear the entire global record and initialize it with a new name */
 406 {
 407     trailer = FALSE;
 408     memset(&current,'\0',sizeof(current));
 409     current.smtp_socket = -1;
 410     current.server.pollname = xstrdup(name);
 411     current.server.skip = skip;
 412 }
 413
 414
 415 static void user_reset(void)
 416 /* clear the global current record (user parameters) used by the parser */
 417 {
 418     struct hostdata save;
 419
 420     /*
 421      * Purpose of this code is to initialize the new server block, but
 422      * preserve whatever server name was previously set.  Also
 423      * preserve server options unless the command-line explicitly
 424      * overrides them.
 425      */
 426     save = current.server;
 427
 428     memset(&current, '\0', sizeof(current));
 429     current.smtp_socket = -1;
 430
 431     current.server = save;
 432 }
 433
 434 struct query *hostalloc(init)
 435 /* append a host record to the host list */
 436 struct query *init;     /* pointer to block containing initial values */
 437 {
 438     struct query *node;
 439
 440     /* allocate new node */
 441     node = (struct query *) xmalloc(sizeof(struct query));
 442
 443     /* initialize it */
 444     if (init)
 445         memcpy(node, init, sizeof(struct query));
 446     else
 447     {
 448         memset(node, '\0', sizeof(struct query));
 449         node->smtp_socket = -1;
 450     }
 451
 452     /* append to end of list */
 453     if (hosttail != (struct query *) 0)
 454         hosttail->next = node;  /* list contains at least one element */
 455     else
 456         querylist = node;       /* list is empty */
 457     hosttail = node;
 458
 459     if (trailer)
 460         node->server.lead_server = leadentry;
 461     else
 462     {
 463         node->server.lead_server = NULL;
 464         leadentry = &node->server;
 465     }
 466
 467     return(node);
 468 }
 469
 470 static void record_current(void)
 471 /* register current parameters and append to the host list */
 472 {
 473     (void) hostalloc(&current);
 474     trailer = TRUE;
 475 }
 476
 477 /* easier to do this than cope with variations in where the library lives */
 478 int yywrap(void) {return 1;}
 479
 480 /* rcfile_y.y ends here */
 481
 482