lib/netrc.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2010, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at http://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ***************************************************************************/
  22
  23 #include "setup.h"
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #ifdef HAVE_UNISTD_H
  30 #include <unistd.h>
  31 #endif
  32 #ifdef HAVE_PWD_H
  33 #include <pwd.h>
  34 #endif
  35 #ifdef __VMS
  36 #include <unixlib.h>
  37 #endif
  38
  39 #include <curl/curl.h>
  40 #include "netrc.h"
  41
  42 #include "strequal.h"
  43 #include "strtok.h"
  44 #include "curl_memory.h"
  45 #include "rawstr.h"
  46
  47 #define _MPRINTF_REPLACE /* use our functions only */
  48 #include <curl/mprintf.h>
  49
  50 /* The last #include file should be: */
  51 #include "memdebug.h"
  52
  53 /* Debug this single source file with:
  54    'make netrc' then run './netrc'!
  55
  56    Oh, make sure you have a .netrc file too ;-)
  57  */
  58
  59 /* Get user and password from .netrc when given a machine name */
  60
  61 enum {
  62   NOTHING,
  63   HOSTFOUND,    /* the 'machine' keyword was found */
  64   HOSTCOMPLETE, /* the machine name following the keyword was found too */
  65   HOSTVALID,    /* this is "our" machine! */
  66
  67   HOSTEND /* LAST enum */
  68 };
  69
  70 /* make sure we have room for at least this size: */
  71 #define LOGINSIZE 64
  72 #define PASSWORDSIZE 64
  73
  74 /* returns -1 on failure, 0 if the host is found, 1 is the host isn't found */
  75 int Curl_parsenetrc(const char *host,
  76                     char *login,
  77                     char *password,
  78                     char *netrcfile)
  79 {
  80   FILE *file;
  81   int retcode=1;
  82   int specific_login = (login[0] != 0);
  83   char *home = NULL;
  84   bool home_alloc = FALSE;
  85   bool netrc_alloc = FALSE;
  86   int state=NOTHING;
  87
  88   char state_login=0;      /* Found a login keyword */
  89   char state_password=0;   /* Found a password keyword */
  90   int state_our_login=FALSE;  /* With specific_login, found *our* login name */
  91
  92 #define NETRC DOT_CHAR "netrc"
  93
  94 #ifdef DEBUGBUILD
  95   {
  96     /* This is a hack to allow testing.
  97      * If compiled with --enable-debug and CURL_DEBUG_NETRC is defined,
  98      * then it's the path to a substitute .netrc for testing purposes *only* */
  99
 100     char *override = curl_getenv("CURL_DEBUG_NETRC");
 101
 102     if(override) {
 103       fprintf(stderr, "NETRC: overridden " NETRC " file: %s\n", override);
 104       netrcfile = override;
 105       netrc_alloc = TRUE;
 106     }
 107   }
 108 #endif /* DEBUGBUILD */
 109   if(!netrcfile) {
 110     home = curl_getenv("HOME"); /* portable environment reader */
 111     if(home) {
 112       home_alloc = TRUE;
 113 #if defined(HAVE_GETPWUID) && defined(HAVE_GETEUID)
 114     }
 115     else {
 116       struct passwd *pw;
 117       pw= getpwuid(geteuid());
 118       if(pw) {
 119 #ifdef __VMS
 120         home = decc_translate_vms(pw->pw_dir);
 121 #else
 122         home = pw->pw_dir;
 123 #endif
 124       }
 125 #endif
 126     }
 127
 128     if(!home)
 129       return -1;
 130
 131     netrcfile = curl_maprintf("%s%s%s", home, DIR_CHAR, NETRC);
 132     if(!netrcfile) {
 133       if(home_alloc)
 134         free(home);
 135       return -1;
 136     }
 137     netrc_alloc = TRUE;
 138   }
 139
 140   file = fopen(netrcfile, "r");
 141   if(file) {
 142     char *tok;
 143     char *tok_buf;
 144     bool done=FALSE;
 145     char netrcbuffer[256];
 146     int  netrcbuffsize = (int)sizeof(netrcbuffer);
 147
 148     while(!done && fgets(netrcbuffer, netrcbuffsize, file)) {
 149       tok=strtok_r(netrcbuffer, " \t\n", &tok_buf);
 150       while(!done && tok) {
 151
 152         if(login[0] && password[0]) {
 153           done=TRUE;
 154           break;
 155         }
 156
 157         switch(state) {
 158         case NOTHING:
 159           if(Curl_raw_equal("machine", tok)) {
 160             /* the next tok is the machine name, this is in itself the
 161                delimiter that starts the stuff entered for this machine,
 162                after this we need to search for 'login' and
 163                'password'. */
 164             state=HOSTFOUND;
 165           }
 166           break;
 167         case HOSTFOUND:
 168           if(Curl_raw_equal(host, tok)) {
 169             /* and yes, this is our host! */
 170             state=HOSTVALID;
 171 #ifdef _NETRC_DEBUG
 172             fprintf(stderr, "HOST: %s\n", tok);
 173 #endif
 174             retcode=0; /* we did find our host */
 175           }
 176           else
 177             /* not our host */
 178             state=NOTHING;
 179           break;
 180         case HOSTVALID:
 181           /* we are now parsing sub-keywords concerning "our" host */
 182           if(state_login) {
 183             if(specific_login) {
 184               state_our_login = Curl_raw_equal(login, tok);
 185             }
 186             else {
 187               strncpy(login, tok, LOGINSIZE-1);
 188 #ifdef _NETRC_DEBUG
 189               fprintf(stderr, "LOGIN: %s\n", login);
 190 #endif
 191             }
 192             state_login=0;
 193           }
 194           else if(state_password) {
 195             if(state_our_login || !specific_login) {
 196               strncpy(password, tok, PASSWORDSIZE-1);
 197 #ifdef _NETRC_DEBUG
 198               fprintf(stderr, "PASSWORD: %s\n", password);
 199 #endif
 200             }
 201             state_password=0;
 202           }
 203           else if(Curl_raw_equal("login", tok))
 204             state_login=1;
 205           else if(Curl_raw_equal("password", tok))
 206             state_password=1;
 207           else if(Curl_raw_equal("machine", tok)) {
 208             /* ok, there's machine here go => */
 209             state = HOSTFOUND;
 210             state_our_login = FALSE;
 211           }
 212           break;
 213         } /* switch (state) */
 214
 215         tok = strtok_r(NULL, " \t\n", &tok_buf);
 216       } /* while(tok) */
 217     } /* while fgets() */
 218
 219     fclose(file);
 220   }
 221
 222   if(home_alloc)
 223     free(home);
 224   if(netrc_alloc)
 225     free(netrcfile);
 226
 227   return retcode;
 228 }
 229
 230 #ifdef _NETRC_DEBUG
 231 int main(int argc, argv_item_t argv[])
 232 {
 233   char login[64]="";
 234   char password[64]="";
 235
 236   if(argc<2)
 237     return -1;
 238
 239   if(0 == ParseNetrc(argv[1], login, password)) {
 240     printf("HOST: %s LOGIN: %s PASSWORD: %s\n",
 241            argv[1], login, password);
 242   }
 243 }
 244
 245 #endif