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