examples/libsmbclient/testbrowse.c

   1 #include <sys/types.h>
   2 #include <unistd.h>
   3 #include <dirent.h>
   4 #include <errno.h>
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <popt.h>
   8 #include <stdlib.h>
   9 #include <libsmbclient.h>
  10 #include "get_auth_data_fn.h"
  11
  12 static void
  13 no_auth_data_fn(const char * pServer,
  14                 const char * pShare,
  15                 char * pWorkgroup,
  16                 int maxLenWorkgroup,
  17                 char * pUsername,
  18                 int maxLenUsername,
  19                 char * pPassword,
  20                 int maxLenPassword);
  21
  22 static void browse(char * path,
  23                    int scan,
  24                    int indent);
  25
  26
  27 static void
  28 get_auth_data_with_context_fn(SMBCCTX * context,
  29                               const char * pServer,
  30                               const char * pShare,
  31                               char * pWorkgroup,
  32                               int maxLenWorkgroup,
  33                               char * pUsername,
  34                               int maxLenUsername,
  35                               char * pPassword,
  36                               int maxLenPassword);
  37
  38 int
  39 main(int argc, char * argv[])
  40 {
  41     int                         debug = 0;
  42     int                         debug_stderr = 0;
  43     int                         no_auth = 0;
  44     int                         context_auth = 0;
  45     int                         scan = 0;
  46     int                         iterations = -1;
  47     int                         again;
  48     int                         opt;
  49     char *                      p;
  50     char *                      q;
  51     char                        buf[1024];
  52     poptContext                 pc;
  53     SMBCCTX *                   context;
  54     struct poptOption           long_options[] =
  55         {
  56             POPT_AUTOHELP
  57             {
  58                 "debug", 'd', POPT_ARG_INT, &debug,
  59                 0, "Set debug level", "integer"
  60             },
  61             {
  62                 "stderr", 'e', POPT_ARG_NONE, &debug_stderr,
  63                 0, "Debug log to stderr instead of stdout", "integer"
  64             },
  65             {
  66                 "scan", 's', POPT_ARG_NONE, &scan,
  67                 0, "Scan for servers and shares", "integer"
  68             },
  69             {
  70                 "iterations", 'i', POPT_ARG_INT, &iterations,
  71                 0, "Iterations", "integer"
  72             },
  73             {
  74                 "noauth", 'A', POPT_ARG_NONE, &no_auth,
  75                 0, "Do not request authentication data", "integer"
  76             },
  77             {
  78                 "contextauth", 'C', POPT_ARG_NONE, &context_auth,
  79                 0, "Use new authentication function with context", "integer"
  80             },
  81             {
  82                 NULL
  83             }
  84         };
  85
  86     setbuf(stdout, NULL);
  87
  88     pc = poptGetContext("opendir", argc, (const char **)argv, long_options, 0);
  89
  90     poptSetOtherOptionHelp(pc, "");
  91
  92     while ((opt = poptGetNextOpt(pc)) != -1) {
  93         printf("Got option %d = %c\n", opt, opt);
  94         switch (opt) {
  95         }
  96     }
  97
  98     /* Allocate a new context */
  99     context = smbc_new_context();
 100     if (!context) {
 101         printf("Could not allocate new smbc context\n");
 102         return 1;
 103     }
 104
 105     /* If we're scanning, do no requests for authentication data */
 106     if (scan) {
 107         no_auth = 1;
 108     }
 109
 110     /* Set mandatory options (is that a contradiction in terms?) */
 111     smbc_setDebug(context, debug);
 112     if (context_auth) {
 113         smbc_setFunctionAuthDataWithContext(context,
 114                                             get_auth_data_with_context_fn);
 115         smbc_setOptionUserData(context, "hello world");
 116     } else {
 117         smbc_setFunctionAuthData(context, get_auth_data_fn);
 118     }
 119
 120     /* If we've been asked to log to stderr instead of stdout, ... */
 121     if (debug_stderr) {
 122         /* ... then set the option to do so */
 123         smbc_setOptionDebugToStderr(context, 1);
 124     }
 125
 126     /* Initialize the context using the previously specified options */
 127     if (!smbc_init_context(context)) {
 128         smbc_free_context(context, 0);
 129         printf("Could not initialize smbc context\n");
 130         return 1;
 131     }
 132
 133     /* Tell the compatibility layer to use this context */
 134     smbc_set_context(context);
 135
 136     if (scan)
 137     {
 138         for (;
 139              iterations == -1 || iterations > 0;
 140              iterations = (iterations == -1 ? iterations : --iterations))
 141         {
 142             snprintf(buf, sizeof(buf), "smb://");
 143             browse(buf, scan, 0);
 144         }
 145     }
 146     else
 147     {
 148         for (;
 149              iterations == -1 || iterations > 0;
 150              iterations = (iterations == -1 ? iterations : --iterations))
 151         {
 152             fputs("url: ", stdout);
 153             p = fgets(buf, sizeof(buf), stdin);
 154             if (! p)
 155             {
 156                 break;
 157             }
 158
 159             if ((p = strchr(buf, '\n')) != NULL)
 160             {
 161                 *p = '\0';
 162             }
 163
 164             browse(buf, scan, 0);
 165         }
 166     }
 167
 168     exit(0);
 169 }
 170
 171
 172 static void
 173 no_auth_data_fn(const char * pServer,
 174                 const char * pShare,
 175                 char * pWorkgroup,
 176                 int maxLenWorkgroup,
 177                 char * pUsername,
 178                 int maxLenUsername,
 179                 char * pPassword,
 180                 int maxLenPassword)
 181 {
 182     return;
 183 }
 184
 185
 186 static void
 187 get_auth_data_with_context_fn(SMBCCTX * context,
 188                               const char * pServer,
 189                               const char * pShare,
 190                               char * pWorkgroup,
 191                               int maxLenWorkgroup,
 192                               char * pUsername,
 193                               int maxLenUsername,
 194                               char * pPassword,
 195                               int maxLenPassword)
 196 {
 197     printf("Authenticating with context 0x%lx", context);
 198     if (context != NULL) {
 199         char *user_data = smbc_getOptionUserData(context);
 200         printf(" with user data %s", user_data);
 201     }
 202     printf("\n");
 203
 204     get_auth_data_fn(pServer, pShare, pWorkgroup, maxLenWorkgroup,
 205                      pUsername, maxLenUsername, pPassword, maxLenPassword);
 206 }
 207
 208 static void browse(char * path, int scan, int indent)
 209 {
 210     char *                      p;
 211     char                        buf[1024];
 212     int                         dir;
 213     struct stat                 stat;
 214     struct smbc_dirent *        dirent;
 215
 216     if (! scan)
 217     {
 218         printf("Opening (%s)...\n", path);
 219     }
 220
 221     if ((dir = smbc_opendir(path)) < 0)
 222     {
 223         printf("Could not open directory [%s] (%d:%s)\n",
 224                path, errno, strerror(errno));
 225         return;
 226     }
 227
 228     while ((dirent = smbc_readdir(dir)) != NULL)
 229     {
 230         printf("%*.*s%-30s", indent, indent, "", dirent->name);
 231
 232         switch(dirent->smbc_type)
 233         {
 234         case SMBC_WORKGROUP:
 235             printf("WORKGROUP");
 236             break;
 237
 238         case SMBC_SERVER:
 239             printf("SERVER");
 240             break;
 241
 242         case SMBC_FILE_SHARE:
 243             printf("FILE_SHARE");
 244             break;
 245
 246         case SMBC_PRINTER_SHARE:
 247             printf("PRINTER_SHARE");
 248             break;
 249
 250         case SMBC_COMMS_SHARE:
 251             printf("COMMS_SHARE");
 252             break;
 253
 254         case SMBC_IPC_SHARE:
 255             printf("IPC_SHARE");
 256             break;
 257
 258         case SMBC_DIR:
 259             printf("DIR");
 260             break;
 261
 262         case SMBC_FILE:
 263             printf("FILE");
 264
 265             p = path + strlen(path);
 266             strcat(p, "/");
 267             strcat(p+1, dirent->name);
 268             if (smbc_stat(path, &stat) < 0)
 269             {
 270                 printf(" unknown size (reason %d: %s)",
 271                        errno, strerror(errno));
 272             }
 273             else
 274             {
 275                 printf(" size %lu", (unsigned long) stat.st_size);
 276             }
 277             *p = '\0';
 278
 279             break;
 280
 281         case SMBC_LINK:
 282             printf("LINK");
 283             break;
 284         }
 285
 286         printf("\n");
 287
 288         if (scan &&
 289             (dirent->smbc_type == SMBC_WORKGROUP ||
 290              dirent->smbc_type == SMBC_SERVER))
 291         {
 292             /*
 293              * don't append server name to workgroup; what we want is:
 294              *
 295              *   smb://workgroup_name
 296              * or
 297              *   smb://server_name
 298              *
 299              */
 300             snprintf(buf, sizeof(buf), "smb://%s", dirent->name);
 301             browse(buf, scan, indent + 2);
 302         }
 303     }
 304
 305     smbc_closedir(dir);
 306 }
 307