apt-pkg/contrib/netrc.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: netrc.c,v 1.38 2007-11-07 09:21:35 bagder Exp $
   4 /* ######################################################################
   5
   6    netrc file parser - returns the login and password of a give host in
   7                        a specified netrc-type file
   8
   9    Originally written by Daniel Stenberg, <daniel@haxx.se>, et al. and
  10    placed into the Public Domain, do with it what you will.
  11
  12    ##################################################################### */
  13                                                                         /*}}}*/
  14 #include <config.h>
  15
  16 #include <apt-pkg/configuration.h>
  17 #include <apt-pkg/strutl.h>
  18 #include <apt-pkg/fileutl.h>
  19
  20 #include <iostream>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <pwd.h>
  26
  27 #include "netrc.h"
  28
  29 using std::string;
  30
  31 /* Get user and password from .netrc when given a machine name */
  32
  33 enum {
  34   NOTHING,
  35   HOSTFOUND,    /* the 'machine' keyword was found */
  36   HOSTCOMPLETE, /* the machine name following the keyword was found too */
  37   HOSTVALID,    /* this is "our" machine! */
  38   HOSTEND /* LAST enum */
  39 };
  40
  41 /* make sure we have room for at least this size: */
  42 #define LOGINSIZE 64
  43 #define PASSWORDSIZE 64
  44 #define NETRC DOT_CHAR "netrc"
  45
  46 /* returns -1 on failure, 0 if the host is found, 1 is the host isn't found */
  47 int parsenetrc (char *host, char *login, char *password, char *netrcfile = NULL)
  48 {
  49   FILE *file;
  50   int retcode = 1;
  51   int specific_login = (login[0] != 0);
  52   char *home = NULL;
  53   bool netrc_alloc = false;
  54
  55   int state_our_login = false;  /* With specific_login,
  56                                    found *our* login name */
  57
  58   if (!netrcfile) {
  59     home = getenv ("HOME"); /* portable environment reader */
  60
  61     if (!home) {
  62       struct passwd *pw;
  63       pw = getpwuid (geteuid ());
  64       if(pw)
  65         home = pw->pw_dir;
  66     }
  67
  68     if (!home)
  69       return -1;
  70
  71     if (asprintf (&netrcfile, "%s%s%s", home, DIR_CHAR, NETRC) == -1 || netrcfile == NULL)
  72       return -1;
  73     else
  74       netrc_alloc = true;
  75   }
  76
  77   file = fopen (netrcfile, "r");
  78   if(file) {
  79     char *tok;
  80     char *tok_buf;
  81     bool done = false;
  82     char netrcbuffer[256];
  83
  84     int state = NOTHING;
  85     char state_login = 0;        /* Found a login keyword */
  86     char state_password = 0;     /* Found a password keyword */
  87
  88     while (!done && fgets(netrcbuffer, sizeof (netrcbuffer), file)) {
  89       tok = strtok_r (netrcbuffer, " \t\n", &tok_buf);
  90       while (!done && tok) {
  91         if(login[0] && password[0]) {
  92           done = true;
  93           break;
  94         }
  95
  96         switch(state) {
  97         case NOTHING:
  98           if (!strcasecmp ("machine", tok)) {
  99             /* the next tok is the machine name, this is in itself the
 100                delimiter that starts the stuff entered for this machine,
 101                after this we need to search for 'login' and
 102                'password'. */
 103             state = HOSTFOUND;
 104           }
 105           break;
 106         case HOSTFOUND:
 107            /* extended definition of a "machine" if we have a "/"
 108               we match the start of the string (host.startswith(token) */
 109           if ((strchr(host, '/') && strstr(host, tok) == host) ||
 110               (!strcasecmp (host, tok))) {
 111             /* and yes, this is our host! */
 112             state = HOSTVALID;
 113             retcode = 0; /* we did find our host */
 114           }
 115           else
 116             /* not our host */
 117             state = NOTHING;
 118           break;
 119         case HOSTVALID:
 120           /* we are now parsing sub-keywords concerning "our" host */
 121           if (state_login) {
 122             if (specific_login)
 123               state_our_login = !strcasecmp (login, tok);
 124             else
 125               strncpy (login, tok, LOGINSIZE - 1);
 126             state_login = 0;
 127           } else if (state_password) {
 128             if (state_our_login || !specific_login)
 129               strncpy (password, tok, PASSWORDSIZE - 1);
 130             state_password = 0;
 131           } else if (!strcasecmp ("login", tok))
 132             state_login = 1;
 133           else if (!strcasecmp ("password", tok))
 134             state_password = 1;
 135           else if(!strcasecmp ("machine", tok)) {
 136             /* ok, there's machine here go => */
 137             state = HOSTFOUND;
 138             state_our_login = false;
 139           }
 140           break;
 141         } /* switch (state) */
 142
 143         tok = strtok_r (NULL, " \t\n", &tok_buf);
 144       } /* while(tok) */
 145     } /* while fgets() */
 146
 147     fclose(file);
 148   }
 149
 150   if (netrc_alloc)
 151     free(netrcfile);
 152
 153   return retcode;
 154 }
 155
 156 void maybe_add_auth (URI &Uri, string NetRCFile)
 157 {
 158   if (_config->FindB("Debug::Acquire::netrc", false) == true)
 159      std::clog << "maybe_add_auth: " << (string)Uri
 160                << " " << NetRCFile << std::endl;
 161   if (Uri.Password.empty () == true || Uri.User.empty () == true)
 162   {
 163     if (NetRCFile.empty () == false)
 164     {
 165       char login[64] = "";
 166       char password[64] = "";
 167       char *netrcfile = strdup(NetRCFile.c_str());
 168
 169       // first check for a generic host based netrc entry
 170       char *host = strdup(Uri.Host.c_str());
 171       if (host && parsenetrc (host, login, password, netrcfile) == 0)
 172       {
 173          if (_config->FindB("Debug::Acquire::netrc", false) == true)
 174             std::clog << "host: " << host
 175                       << " user: " << login
 176                       << " pass-size: " << strlen(password)
 177                       << std::endl;
 178         Uri.User = string (login);
 179         Uri.Password = string (password);
 180         free(netrcfile);
 181         free(host);
 182         return;
 183       }
 184       free(host);
 185
 186       // if host did not work, try Host+Path next, this will trigger
 187       // a lookup uri.startswith(host) in the netrc file parser (because
 188       // of the "/"
 189       char *hostpath = strdup(string(Uri.Host+Uri.Path).c_str());
 190       if (hostpath && parsenetrc (hostpath, login, password, netrcfile) == 0)
 191       {
 192          if (_config->FindB("Debug::Acquire::netrc", false) == true)
 193             std::clog << "hostpath: " << hostpath
 194                       << " user: " << login
 195                       << " pass-size: " << strlen(password)
 196                       << std::endl;
 197          Uri.User = string (login);
 198          Uri.Password = string (password);
 199       }
 200       free(netrcfile);
 201       free(hostpath);
 202     }
 203   }
 204 }
 205
 206 #ifdef DEBUG
 207 int main(int argc, char* argv[])
 208 {
 209   char login[64] = "";
 210   char password[64] = "";
 211
 212   if(argc < 2)
 213     return -1;
 214
 215   if(0 == parsenetrc (argv[1], login, password, argv[2])) {
 216     printf("HOST: %s LOGIN: %s PASSWORD: %s\n", argv[1], login, password);
 217   }
 218 }
 219 #endif