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 SDPS 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 PROPERTIES
  67 %token SET LOGFILE DAEMON SYSLOG IDFILE INVISIBLE POSTMASTER WARNINGS
  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
 132                                             if (current.server.preauthenticate == A_PASSWORD)
 133 #ifdef KERBEROS_V5
 134                                                 current.server.preauthenticate = A_KERBEROS_V5;
 135 #else
 136                                                 current.server.preauthenticate = A_KERBEROS_V4;
 137 #endif /* KERBEROS_V5 */
 138 #if INET6
 139                                             current.server.service = KPOP_PORT;
 140 #else /* INET6 */
 141                                             current.server.port = KPOP_PORT;
 142 #endif /* INET6 */
 143                                         }
 144                 | PROTOCOL SDPS         {
 145 #ifdef SDPS_ENABLE
 146                                             current.server.protocol = P_POP3;
 147                                             current.server.sdps = TRUE;
 148 #else
 149                                             yyerror("SDPS not enabled.");
 150 #endif /* SDPS_ENABLE */
 151                                         }
 152                 | UIDL                  {current.server.uidl = FLAG_TRUE;}
 153                 | NO UIDL               {current.server.uidl  = FLAG_FALSE;}
 154                 | CHECKALIAS            {current.server.checkalias = FLAG_TRUE;}
 155                 | NO CHECKALIAS         {current.server.checkalias  = FLAG_FALSE;}
 156                 | SERVICE STRING        {
 157 #if INET6
 158                                         current.server.service = $2;
 159 #endif /* INET6 */
 160                                         }
 161                 | PORT NUMBER           {
 162 #if !INET6
 163                                         current.server.port = $2;
 164 #endif /* !INET6 */
 165                                         }
 166                 | INTERVAL NUMBER               {current.server.interval = $2;}
 167                 | AUTHENTICATE PASSWORD {current.server.preauthenticate = A_PASSWORD;}
 168                 | AUTHENTICATE KERBEROS4        {current.server.preauthenticate = A_KERBEROS_V4;}
 169                 | AUTHENTICATE KERBEROS5        {current.server.preauthenticate = A_KERBEROS_V5;}
 170                 | AUTHENTICATE KERBEROS         {
 171 #ifdef KERBEROS_V5
 172                     current.server.preauthenticate = A_KERBEROS_V5;
 173 #else
 174                     current.server.preauthenticate = A_KERBEROS_V4;
 175 #endif /* KERBEROS_V5 */
 176                 }
 177                 | TIMEOUT NUMBER        {current.server.timeout = $2;}
 178
 179                 | ENVELOPE NUMBER STRING
 180                                         {
 181                                             current.server.envelope =
 182                                                 xstrdup($3);
 183                                             current.server.envskip = $2;
 184                                         }
 185                 | ENVELOPE STRING
 186                                         {
 187                                             current.server.envelope =
 188                                                 xstrdup($2);
 189                                             current.server.envskip = 0;
 190                                         }
 191
 192                 | QVIRTUAL STRING       {current.server.qvirtual=xstrdup($2);}
 193                 | NETSEC STRING         {
 194 #ifdef NET_SECURITY
 195                                             void *request;
 196                                             int requestlen;
 197
 198                                             if (net_security_strtorequest($2, &request, &requestlen))
 199                                                 yyerror("invalid security request");
 200                                             else {
 201                                                 current.server.netsec = xstrdup($2);
 202                                                 free(request);
 203                                             }
 204 #else
 205                                             yyerror("network-security support disabled");
 206 #endif /* NET_SECURITY */
 207                                         }
 208                 | INTERFACE STRING      {
 209 #if defined(linux) && !defined(INET6)
 210                                         interface_parse($2, &current.server);
 211 #else /* defined(linux) && !defined(INET6) */
 212                                         fprintf(stderr, "fetchmail: interface option is only supported under Linux\n");
 213 #endif /* defined(linux) && !defined(INET6) */
 214                                         }
 215                 | MONITOR STRING        {
 216 #if defined(linux) && !defined(INET6)
 217                                         current.server.monitor = xstrdup($2);
 218 #else /* defined(linux) && !defined(INET6) */
 219                                         fprintf(stderr, "fetchmail: monitor option is only supported under Linux\n");
 220 #endif /* defined(linux) && !defined(INET6) */
 221                                         }
 222                 | DNS                   {current.server.dns = FLAG_TRUE;}
 223                 | NO DNS                {current.server.dns = FLAG_FALSE;}
 224                 | NO ENVELOPE           {current.server.envelope = STRING_DISABLED;}
 225                 ;
 226
 227 userspecs       : user1opts             {record_current(); user_reset();}
 228                 | explicits
 229                 ;
 230
 231 explicits       : explicitdef           {record_current(); user_reset();}
 232                 | explicits explicitdef {record_current(); user_reset();}
 233                 ;
 234
 235 explicitdef     : userdef user0opts
 236                 ;
 237
 238 userdef         : USERNAME STRING       {current.remotename = xstrdup($2);}
 239                 | USERNAME mapping_list HERE
 240                 | USERNAME STRING THERE {current.remotename = xstrdup($2);}
 241                 ;
 242
 243 user0opts       : /* EMPTY */
 244                 | user0opts user_option
 245                 ;
 246
 247 user1opts       : user_option
 248                 | user1opts user_option
 249                 ;
 250
 251 localnames      : WILDCARD              {current.wildcard =  TRUE;}
 252                 | mapping_list          {current.wildcard =  FALSE;}
 253                 | mapping_list WILDCARD {current.wildcard =  TRUE;}
 254                 ;
 255
 256 mapping_list    : mapping
 257                 | mapping_list mapping
 258                 ;
 259
 260 mapping         : STRING
 261                                 {save_str_pair(&current.localnames, $1, NULL);}
 262                 | STRING MAP STRING
 263                                 {save_str_pair(&current.localnames, $1, $3);}
 264                 ;
 265
 266 folder_list     : STRING                {save_str(&current.mailboxes,$1,0);}
 267                 | folder_list STRING    {save_str(&current.mailboxes,$2,0);}
 268                 ;
 269
 270 smtp_list       : STRING                {save_str(&current.smtphunt, $1,TRUE);}
 271                 | smtp_list STRING      {save_str(&current.smtphunt, $2,TRUE);}
 272                 ;
 273
 274 num_list        : NUMBER
 275                         {
 276                             struct idlist *id;
 277                             id=save_str(&current.antispam,STRING_DUMMY,0);
 278                             id->val.status.num = $1;
 279                         }
 280                 | num_list NUMBER
 281                         {
 282                             struct idlist *id;
 283                             id=save_str(&current.antispam,STRING_DUMMY,0);
 284                             id->val.status.num = $2;
 285                         }
 286                 ;
 287
 288 user_option     : TO localnames HERE
 289                 | TO localnames
 290                 | IS localnames HERE
 291                 | IS localnames
 292
 293                 | IS STRING THERE       {current.remotename = xstrdup($2);}
 294                 | PASSWORD STRING       {current.password   = xstrdup($2);}
 295                 | FOLDER folder_list
 296                 | SMTPHOST smtp_list
 297                 | SMTPADDRESS STRING    {current.smtpaddress = xstrdup($2);}
 298                 | SPAMRESPONSE num_list
 299                 | MDA STRING            {current.mda        = xstrdup($2);}
 300                 | PRECONNECT STRING     {current.preconnect = xstrdup($2);}
 301                 | POSTCONNECT STRING    {current.postconnect = xstrdup($2);}
 302
 303                 | KEEP                  {current.keep       = FLAG_TRUE;}
 304                 | FLUSH                 {current.flush      = FLAG_TRUE;}
 305                 | FETCHALL              {current.fetchall   = FLAG_TRUE;}
 306                 | REWRITE               {current.rewrite    = FLAG_TRUE;}
 307                 | FORCECR               {current.forcecr    = FLAG_TRUE;}
 308                 | STRIPCR               {current.stripcr    = FLAG_TRUE;}
 309                 | PASS8BITS             {current.pass8bits  = FLAG_TRUE;}
 310                 | DROPSTATUS            {current.dropstatus = FLAG_TRUE;}
 311                 | MIMEDECODE            {current.mimedecode = FLAG_TRUE;}
 312
 313                 | NO KEEP               {current.keep       = FLAG_FALSE;}
 314                 | NO FLUSH              {current.flush      = FLAG_FALSE;}
 315                 | NO FETCHALL           {current.fetchall   = FLAG_FALSE;}
 316                 | NO REWRITE            {current.rewrite    = FLAG_FALSE;}
 317                 | NO FORCECR            {current.forcecr    = FLAG_FALSE;}
 318                 | NO STRIPCR            {current.stripcr    = FLAG_FALSE;}
 319                 | NO PASS8BITS          {current.pass8bits  = FLAG_FALSE;}
 320                 | NO DROPSTATUS         {current.dropstatus = FLAG_FALSE;}
 321                 | NO MIMEDECODE         {current.mimedecode = FLAG_FALSE;}
 322
 323                 | LIMIT NUMBER          {current.limit      = NUM_VALUE($2);}
 324                 | WARNINGS NUMBER       {current.warnings   = NUM_VALUE($2);}
 325                 | FETCHLIMIT NUMBER     {current.fetchlimit = NUM_VALUE($2);}
 326                 | BATCHLIMIT NUMBER     {current.batchlimit = NUM_VALUE($2);}
 327                 | EXPUNGE NUMBER        {current.expunge    = NUM_VALUE($2);}
 328
 329                 | PROPERTIES STRING     {current.properties = xstrdup($2);}
 330                 ;
 331 %%
 332
 333 /* lexer interface */
 334 extern char *rcfile;
 335 extern int prc_lineno;
 336 extern char *yytext;
 337 extern FILE *yyin;
 338
 339 static struct query *hosttail;  /* where to add new elements */
 340
 341 void yyerror (const char *s)
 342 /* report a syntax error */
 343 {
 344     error_at_line( 0, 0, rcfile, prc_lineno, "%s at %s", s,
 345                    (yytext && yytext[0]) ? yytext : "end of input");
 346     prc_errflag++;
 347 }
 348
 349 int prc_filecheck(const char *pathname, const flag securecheck)
 350 /* check that a configuration file is secure */
 351 {
 352 #ifndef __EMX__
 353     struct stat statbuf;
 354
 355     errno = 0;
 356
 357     /* special cases useful for debugging purposes */
 358     if (strcmp("/dev/null", pathname) == 0)
 359         return(PS_SUCCESS);
 360
 361     /* the run control file must have the same uid as the REAL uid of this
 362        process, it must have permissions no greater than 600, and it must not
 363        be a symbolic link.  We check these conditions here. */
 364
 365     if (lstat(pathname, &statbuf) < 0) {
 366         if (errno == ENOENT)
 367             return(PS_SUCCESS);
 368         else {
 369             error(0, errno, "lstat: %s", pathname);
 370             return(PS_IOERR);
 371         }
 372     }
 373
 374     if (!securecheck)   return 0;
 375
 376     if ((statbuf.st_mode & S_IFLNK) == S_IFLNK)
 377     {
 378         fprintf(stderr, "File %s must not be a symbolic link.\n", pathname);
 379         return(PS_AUTHFAIL);
 380     }
 381
 382     if (statbuf.st_mode & ~(S_IFREG | S_IREAD | S_IWRITE | S_IEXEC | S_IXGRP))
 383     {
 384         fprintf(stderr, "File %s must have no more than -rwx--x--- (0710) permissions.\n",
 385                 pathname);
 386         return(PS_AUTHFAIL);
 387     }
 388
 389     if (statbuf.st_uid != getuid())
 390     {
 391         fprintf(stderr, "File %s must be owned by you.\n", pathname);
 392         return(PS_AUTHFAIL);
 393     }
 394 #endif
 395     return(PS_SUCCESS);
 396 }
 397
 398 int prc_parse_file (const char *pathname, const flag securecheck)
 399 /* digest the configuration into a linked list of host records */
 400 {
 401     prc_errflag = 0;
 402     querylist = hosttail = (struct query *)NULL;
 403
 404     errno = 0;
 405
 406     /* Check that the file is secure */
 407     if ( (prc_errflag = prc_filecheck(pathname, securecheck)) != 0 )
 408         return(prc_errflag);
 409
 410     if (errno == ENOENT)
 411         return(PS_SUCCESS);
 412
 413     /* Open the configuration and feed it to the lexer. */
 414     if ((yyin = fopen(pathname,"r")) == (FILE *)NULL) {
 415         error(0, errno, "open: %s", pathname);
 416         return(PS_IOERR);
 417     }
 418
 419     yyparse();          /* parse entire file */
 420
 421     fclose(yyin);
 422
 423     if (prc_errflag)
 424         return(PS_SYNTAX);
 425     else
 426         return(PS_SUCCESS);
 427 }
 428
 429 static void reset_server(char *name, int skip)
 430 /* clear the entire global record and initialize it with a new name */
 431 {
 432     trailer = FALSE;
 433     memset(&current,'\0',sizeof(current));
 434     current.smtp_socket = -1;
 435     current.server.pollname = xstrdup(name);
 436     current.server.skip = skip;
 437 }
 438
 439
 440 static void user_reset(void)
 441 /* clear the global current record (user parameters) used by the parser */
 442 {
 443     struct hostdata save;
 444
 445     /*
 446      * Purpose of this code is to initialize the new server block, but
 447      * preserve whatever server name was previously set.  Also
 448      * preserve server options unless the command-line explicitly
 449      * overrides them.
 450      */
 451     save = current.server;
 452
 453     memset(&current, '\0', sizeof(current));
 454     current.smtp_socket = -1;
 455
 456     current.server = save;
 457 }
 458
 459 struct query *hostalloc(init)
 460 /* append a host record to the host list */
 461 struct query *init;     /* pointer to block containing initial values */
 462 {
 463     struct query *node;
 464
 465     /* allocate new node */
 466     node = (struct query *) xmalloc(sizeof(struct query));
 467
 468     /* initialize it */
 469     if (init)
 470         memcpy(node, init, sizeof(struct query));
 471     else
 472     {
 473         memset(node, '\0', sizeof(struct query));
 474         node->smtp_socket = -1;
 475     }
 476
 477     /* append to end of list */
 478     if (hosttail != (struct query *) 0)
 479         hosttail->next = node;  /* list contains at least one element */
 480     else
 481         querylist = node;       /* list is empty */
 482     hosttail = node;
 483
 484     if (trailer)
 485         node->server.lead_server = leadentry;
 486     else
 487     {
 488         node->server.lead_server = NULL;
 489         leadentry = &node->server;
 490     }
 491
 492     return(node);
 493 }
 494
 495 static void record_current(void)
 496 /* register current parameters and append to the host list */
 497 {
 498     (void) hostalloc(&current);
 499     trailer = TRUE;
 500 }
 501
 502 /* easier to do this than cope with variations in where the library lives */
 503 int yywrap(void) {return 1;}
 504
 505 /* rcfile_y.y ends here */
 506
 507