← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to source3/libsmb/libsmb_context.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
source3/libsmb/libsmb_context.c
 
1
/* 
 
2
   Unix SMB/Netbios implementation.
 
3
   SMB client library implementation
 
4
   Copyright (C) Andrew Tridgell 1998
 
5
   Copyright (C) Richard Sharpe 2000, 2002
 
6
   Copyright (C) John Terpstra 2000
 
7
   Copyright (C) Tom Jansen (Ninja ISD) 2002 
 
8
   Copyright (C) Derrell Lipman 2003-2008
 
9
   Copyright (C) Jeremy Allison 2007, 2008
 
10
   
 
11
   This program is free software; you can redistribute it and/or modify
 
12
   it under the terms of the GNU General Public License as published by
 
13
   the Free Software Foundation; either version 3 of the License, or
 
14
   (at your option) any later version.
 
15
   
 
16
   This program is distributed in the hope that it will be useful,
 
17
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
18
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
19
   GNU General Public License for more details.
 
20
   
 
21
   You should have received a copy of the GNU General Public License
 
22
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
23
*/
 
24
 
 
25
#include "includes.h"
 
26
#include "libsmbclient.h"
 
27
#include "libsmb_internal.h"
 
28
 
 
29
 
 
30
/*
 
31
 * Is the logging working / configfile read ? 
 
32
 */
 
33
static bool SMBC_initialized;
 
34
static unsigned int initialized_ctx_count;
 
35
 
 
36
/*
 
37
 * Get a new empty handle to fill in with your own info
 
38
 */
 
39
SMBCCTX *
 
40
smbc_new_context(void)
 
41
{
 
42
        SMBCCTX *context;
 
43
        
 
44
        /*
 
45
         * All newly added context fields should be placed in
 
46
         * SMBC_internal_data, not directly in SMBCCTX.
 
47
         */
 
48
        context = SMB_MALLOC_P(SMBCCTX);
 
49
        if (!context) {
 
50
                errno = ENOMEM;
 
51
                return NULL;
 
52
        }
 
53
        
 
54
        ZERO_STRUCTP(context);
 
55
        
 
56
        context->internal = SMB_MALLOC_P(struct SMBC_internal_data);
 
57
        if (!context->internal) {
 
58
                SAFE_FREE(context);
 
59
                errno = ENOMEM;
 
60
                return NULL;
 
61
        }
 
62
        
 
63
        /* Initialize the context and establish reasonable defaults */
 
64
        ZERO_STRUCTP(context->internal);
 
65
        
 
66
        smbc_setDebug(context, 0);
 
67
        smbc_setTimeout(context, 20000);
 
68
        
 
69
        smbc_setOptionFullTimeNames(context, False);
 
70
        smbc_setOptionOpenShareMode(context, SMBC_SHAREMODE_DENY_NONE);
 
71
        smbc_setOptionSmbEncryptionLevel(context, SMBC_ENCRYPTLEVEL_NONE);
 
72
        smbc_setOptionCaseSensitive(context, False);
 
73
        smbc_setOptionBrowseMaxLmbCount(context, 3);    /* # LMBs to query */
 
74
        smbc_setOptionUrlEncodeReaddirEntries(context, False);
 
75
        smbc_setOptionOneSharePerServer(context, False);
 
76
        
 
77
        smbc_setFunctionAuthData(context, SMBC_get_auth_data);
 
78
        smbc_setFunctionCheckServer(context, SMBC_check_server);
 
79
        smbc_setFunctionRemoveUnusedServer(context, SMBC_remove_unused_server);
 
80
        
 
81
        smbc_setOptionUserData(context, NULL);
 
82
        smbc_setFunctionAddCachedServer(context, SMBC_add_cached_server);
 
83
        smbc_setFunctionGetCachedServer(context, SMBC_get_cached_server);
 
84
        smbc_setFunctionRemoveCachedServer(context, SMBC_remove_cached_server);
 
85
        smbc_setFunctionPurgeCachedServers(context, SMBC_purge_cached_servers);
 
86
        
 
87
        smbc_setFunctionOpen(context, SMBC_open_ctx);
 
88
        smbc_setFunctionCreat(context, SMBC_creat_ctx);
 
89
        smbc_setFunctionRead(context, SMBC_read_ctx);
 
90
        smbc_setFunctionWrite(context, SMBC_write_ctx);
 
91
        smbc_setFunctionClose(context, SMBC_close_ctx);
 
92
        smbc_setFunctionUnlink(context, SMBC_unlink_ctx);
 
93
        smbc_setFunctionRename(context, SMBC_rename_ctx);
 
94
        smbc_setFunctionLseek(context, SMBC_lseek_ctx);
 
95
        smbc_setFunctionFtruncate(context, SMBC_ftruncate_ctx);
 
96
        smbc_setFunctionStat(context, SMBC_stat_ctx);
 
97
        smbc_setFunctionStatVFS(context, SMBC_statvfs_ctx);
 
98
        smbc_setFunctionFstatVFS(context, SMBC_fstatvfs_ctx);
 
99
        smbc_setFunctionFstat(context, SMBC_fstat_ctx);
 
100
        smbc_setFunctionOpendir(context, SMBC_opendir_ctx);
 
101
        smbc_setFunctionClosedir(context, SMBC_closedir_ctx);
 
102
        smbc_setFunctionReaddir(context, SMBC_readdir_ctx);
 
103
        smbc_setFunctionGetdents(context, SMBC_getdents_ctx);
 
104
        smbc_setFunctionMkdir(context, SMBC_mkdir_ctx);
 
105
        smbc_setFunctionRmdir(context, SMBC_rmdir_ctx);
 
106
        smbc_setFunctionTelldir(context, SMBC_telldir_ctx);
 
107
        smbc_setFunctionLseekdir(context, SMBC_lseekdir_ctx);
 
108
        smbc_setFunctionFstatdir(context, SMBC_fstatdir_ctx);
 
109
        smbc_setFunctionChmod(context, SMBC_chmod_ctx);
 
110
        smbc_setFunctionUtimes(context, SMBC_utimes_ctx);
 
111
        smbc_setFunctionSetxattr(context, SMBC_setxattr_ctx);
 
112
        smbc_setFunctionGetxattr(context, SMBC_getxattr_ctx);
 
113
        smbc_setFunctionRemovexattr(context, SMBC_removexattr_ctx);
 
114
        smbc_setFunctionListxattr(context, SMBC_listxattr_ctx);
 
115
        
 
116
        smbc_setFunctionOpenPrintJob(context, SMBC_open_print_job_ctx);
 
117
        smbc_setFunctionPrintFile(context, SMBC_print_file_ctx);
 
118
        smbc_setFunctionListPrintJobs(context, SMBC_list_print_jobs_ctx);
 
119
        smbc_setFunctionUnlinkPrintJob(context, SMBC_unlink_print_job_ctx);
 
120
        
 
121
        return context;
 
122
}
 
123
 
 
124
/*
 
125
 * Free a context
 
126
 *
 
127
 * Returns 0 on success. Otherwise returns 1, the SMBCCTX is _not_ freed
 
128
 * and thus you'll be leaking memory if not handled properly.
 
129
 *
 
130
 */
 
131
int
 
132
smbc_free_context(SMBCCTX *context,
 
133
                  int shutdown_ctx)
 
134
{
 
135
        if (!context) {
 
136
                errno = EBADF;
 
137
                return 1;
 
138
        }
 
139
        
 
140
        if (shutdown_ctx) {
 
141
                SMBCFILE * f;
 
142
                DEBUG(1,("Performing aggressive shutdown.\n"));
 
143
                
 
144
                f = context->internal->files;
 
145
                while (f) {
 
146
                        smbc_getFunctionClose(context)(context, f);
 
147
                        f = f->next;
 
148
                }
 
149
                context->internal->files = NULL;
 
150
                
 
151
                /* First try to remove the servers the nice way. */
 
152
                if (smbc_getFunctionPurgeCachedServers(context)(context)) {
 
153
                        SMBCSRV * s;
 
154
                        SMBCSRV * next;
 
155
                        DEBUG(1, ("Could not purge all servers, "
 
156
                                  "Nice way shutdown failed.\n"));
 
157
                        s = context->internal->servers;
 
158
                        while (s) {
 
159
                                DEBUG(1, ("Forced shutdown: %p (fd=%d)\n",
 
160
                                          s, s->cli->fd));
 
161
                                cli_shutdown(s->cli);
 
162
                                smbc_getFunctionRemoveCachedServer(context)(context,
 
163
                                                                         s);
 
164
                                next = s->next;
 
165
                                DLIST_REMOVE(context->internal->servers, s);
 
166
                                SAFE_FREE(s);
 
167
                                s = next;
 
168
                        }
 
169
                        context->internal->servers = NULL;
 
170
                }
 
171
        }
 
172
        else {
 
173
                /* This is the polite way */
 
174
                if (smbc_getFunctionPurgeCachedServers(context)(context)) {
 
175
                        DEBUG(1, ("Could not purge all servers, "
 
176
                                  "free_context failed.\n"));
 
177
                        errno = EBUSY;
 
178
                        return 1;
 
179
                }
 
180
                if (context->internal->servers) {
 
181
                        DEBUG(1, ("Active servers in context, "
 
182
                                  "free_context failed.\n"));
 
183
                        errno = EBUSY;
 
184
                        return 1;
 
185
                }
 
186
                if (context->internal->files) {
 
187
                        DEBUG(1, ("Active files in context, "
 
188
                                  "free_context failed.\n"));
 
189
                        errno = EBUSY;
 
190
                        return 1;
 
191
                }
 
192
        }
 
193
        
 
194
        /* Things we have to clean up */
 
195
        smbc_setWorkgroup(context, NULL);
 
196
        smbc_setNetbiosName(context, NULL);
 
197
        smbc_setUser(context, NULL);
 
198
        
 
199
        DEBUG(3, ("Context %p successfully freed\n", context));
 
200
 
 
201
        /* Free any DFS auth context. */
 
202
        TALLOC_FREE(context->internal->auth_info);
 
203
 
 
204
        SAFE_FREE(context->internal);
 
205
        SAFE_FREE(context);
 
206
 
 
207
        if (initialized_ctx_count) {
 
208
                initialized_ctx_count--;
 
209
        }
 
210
 
 
211
        if (initialized_ctx_count == 0 && SMBC_initialized) {
 
212
                gencache_shutdown();
 
213
                secrets_shutdown();
 
214
                gfree_all();
 
215
                SMBC_initialized = false;
 
216
        }
 
217
        return 0;
 
218
}
 
219
 
 
220
 
 
221
/**
 
222
 * Deprecated interface.  Do not use.  Instead, use the various
 
223
 * smbc_setOption*() functions or smbc_setFunctionAuthDataWithContext().
 
224
 */
 
225
void
 
226
smbc_option_set(SMBCCTX *context,
 
227
                char *option_name,
 
228
                ... /* option_value */)
 
229
{
 
230
        va_list ap;
 
231
        union {
 
232
                int i;
 
233
                bool b;
 
234
                smbc_get_auth_data_with_context_fn auth_fn;
 
235
                void *v;
 
236
                const char *s;
 
237
        } option_value;
 
238
        
 
239
        va_start(ap, option_name);
 
240
        
 
241
        if (strcmp(option_name, "debug_to_stderr") == 0) {
 
242
                option_value.b = (bool) va_arg(ap, int);
 
243
                smbc_setOptionDebugToStderr(context, option_value.b);
 
244
                
 
245
        } else if (strcmp(option_name, "full_time_names") == 0) {
 
246
                option_value.b = (bool) va_arg(ap, int);
 
247
                smbc_setOptionFullTimeNames(context, option_value.b);
 
248
                
 
249
        } else if (strcmp(option_name, "open_share_mode") == 0) {
 
250
                option_value.i = va_arg(ap, int);
 
251
                smbc_setOptionOpenShareMode(context, option_value.i);
 
252
                
 
253
        } else if (strcmp(option_name, "auth_function") == 0) {
 
254
                option_value.auth_fn =
 
255
                        va_arg(ap, smbc_get_auth_data_with_context_fn);
 
256
                smbc_setFunctionAuthDataWithContext(context, option_value.auth_fn);
 
257
                
 
258
        } else if (strcmp(option_name, "user_data") == 0) {
 
259
                option_value.v = va_arg(ap, void *);
 
260
                smbc_setOptionUserData(context, option_value.v);
 
261
                
 
262
        } else if (strcmp(option_name, "smb_encrypt_level") == 0) {
 
263
                option_value.s = va_arg(ap, const char *);
 
264
                if (strcmp(option_value.s, "none") == 0) {
 
265
                        smbc_setOptionSmbEncryptionLevel(context,
 
266
                                                         SMBC_ENCRYPTLEVEL_NONE);
 
267
                } else if (strcmp(option_value.s, "request") == 0) {
 
268
                        smbc_setOptionSmbEncryptionLevel(context,
 
269
                                                         SMBC_ENCRYPTLEVEL_REQUEST);
 
270
                } else if (strcmp(option_value.s, "require") == 0) {
 
271
                        smbc_setOptionSmbEncryptionLevel(context,
 
272
                                                         SMBC_ENCRYPTLEVEL_REQUIRE);
 
273
                }
 
274
                
 
275
        } else if (strcmp(option_name, "browse_max_lmb_count") == 0) {
 
276
                option_value.i = va_arg(ap, int);
 
277
                smbc_setOptionBrowseMaxLmbCount(context, option_value.i);
 
278
                
 
279
        } else if (strcmp(option_name, "urlencode_readdir_entries") == 0) {
 
280
                option_value.b = (bool) va_arg(ap, int);
 
281
                smbc_setOptionUrlEncodeReaddirEntries(context, option_value.b);
 
282
                
 
283
        } else if (strcmp(option_name, "one_share_per_server") == 0) {
 
284
                option_value.b = (bool) va_arg(ap, int);
 
285
                smbc_setOptionOneSharePerServer(context, option_value.b);
 
286
                
 
287
        } else if (strcmp(option_name, "use_kerberos") == 0) {
 
288
                option_value.b = (bool) va_arg(ap, int);
 
289
                smbc_setOptionUseKerberos(context, option_value.b);
 
290
                
 
291
        } else if (strcmp(option_name, "fallback_after_kerberos") == 0) {
 
292
                option_value.b = (bool) va_arg(ap, int);
 
293
                smbc_setOptionFallbackAfterKerberos(context, option_value.b);
 
294
                
 
295
        } else if (strcmp(option_name, "no_auto_anonymous_login") == 0) {
 
296
                option_value.b = (bool) va_arg(ap, int);
 
297
                smbc_setOptionNoAutoAnonymousLogin(context, option_value.b);
 
298
        }
 
299
        
 
300
        va_end(ap);
 
301
}
 
302
 
 
303
 
 
304
/*
 
305
 * Deprecated interface.  Do not use.  Instead, use the various
 
306
 * smbc_getOption*() functions.
 
307
 */
 
308
void *
 
309
smbc_option_get(SMBCCTX *context,
 
310
                char *option_name)
 
311
{
 
312
        if (strcmp(option_name, "debug_stderr") == 0) {
 
313
#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 
314
                return (void *) (intptr_t) smbc_getOptionDebugToStderr(context);
 
315
#else
 
316
                return (void *) smbc_getOptionDebugToStderr(context);
 
317
#endif
 
318
                
 
319
        } else if (strcmp(option_name, "full_time_names") == 0) {
 
320
#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 
321
                return (void *) (intptr_t) smbc_getOptionFullTimeNames(context);
 
322
#else
 
323
                return (void *) smbc_getOptionFullTimeNames(context);
 
324
#endif
 
325
                
 
326
        } else if (strcmp(option_name, "open_share_mode") == 0) {
 
327
#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 
328
                return (void *) (intptr_t) smbc_getOptionOpenShareMode(context);
 
329
#else
 
330
                return (void *) smbc_getOptionOpenShareMode(context);
 
331
#endif
 
332
                
 
333
        } else if (strcmp(option_name, "auth_function") == 0) {
 
334
                return (void *) smbc_getFunctionAuthDataWithContext(context);
 
335
                
 
336
        } else if (strcmp(option_name, "user_data") == 0) {
 
337
                return smbc_getOptionUserData(context);
 
338
                
 
339
        } else if (strcmp(option_name, "smb_encrypt_level") == 0) {
 
340
                switch(smbc_getOptionSmbEncryptionLevel(context))
 
341
                {
 
342
                case 0:
 
343
                        return (void *) "none";
 
344
                case 1:
 
345
                        return (void *) "request";
 
346
                case 2:
 
347
                        return (void *) "require";
 
348
                }
 
349
                
 
350
        } else if (strcmp(option_name, "smb_encrypt_on") == 0) {
 
351
                SMBCSRV *s;
 
352
                unsigned int num_servers = 0;
 
353
                
 
354
                for (s = context->internal->servers; s; s = s->next) {
 
355
                        num_servers++;
 
356
                        if (s->cli->trans_enc_state == NULL) {
 
357
                                return (void *)false;
 
358
                        }
 
359
                }
 
360
#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 
361
                return (void *) (intptr_t) (bool) (num_servers > 0);
 
362
#else
 
363
                return (void *) (bool) (num_servers > 0);
 
364
#endif
 
365
                
 
366
        } else if (strcmp(option_name, "browse_max_lmb_count") == 0) {
 
367
#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 
368
                return (void *) (intptr_t) smbc_getOptionBrowseMaxLmbCount(context);
 
369
#else
 
370
                return (void *) smbc_getOptionBrowseMaxLmbCount(context);
 
371
#endif
 
372
                
 
373
        } else if (strcmp(option_name, "urlencode_readdir_entries") == 0) {
 
374
#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 
375
                return (void *)(intptr_t) smbc_getOptionUrlEncodeReaddirEntries(context);
 
376
#else
 
377
                return (void *) (bool) smbc_getOptionUrlEncodeReaddirEntries(context);
 
378
#endif
 
379
                
 
380
        } else if (strcmp(option_name, "one_share_per_server") == 0) {
 
381
#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 
382
                return (void *) (intptr_t) smbc_getOptionOneSharePerServer(context);
 
383
#else
 
384
                return (void *) (bool) smbc_getOptionOneSharePerServer(context);
 
385
#endif
 
386
                
 
387
        } else if (strcmp(option_name, "use_kerberos") == 0) {
 
388
#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 
389
                return (void *) (intptr_t) smbc_getOptionUseKerberos(context);
 
390
#else
 
391
                return (void *) (bool) smbc_getOptionUseKerberos(context);
 
392
#endif
 
393
                
 
394
        } else if (strcmp(option_name, "fallback_after_kerberos") == 0) {
 
395
#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 
396
                return (void *)(intptr_t) smbc_getOptionFallbackAfterKerberos(context);
 
397
#else
 
398
                return (void *) (bool) smbc_getOptionFallbackAfterKerberos(context);
 
399
#endif
 
400
                
 
401
        } else if (strcmp(option_name, "no_auto_anonymous_login") == 0) {
 
402
#if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 
403
                return (void *) (intptr_t) smbc_getOptionNoAutoAnonymousLogin(context);
 
404
#else
 
405
                return (void *) (bool) smbc_getOptionNoAutoAnonymousLogin(context);
 
406
#endif
 
407
        }
 
408
        
 
409
        return NULL;
 
410
}
 
411
 
 
412
 
 
413
/*
 
414
 * Initialize the library, etc.
 
415
 *
 
416
 * We accept a struct containing handle information.
 
417
 * valid values for info->debug from 0 to 100,
 
418
 * and insist that info->fn must be non-null.
 
419
 */
 
420
SMBCCTX *
 
421
smbc_init_context(SMBCCTX *context)
 
422
{
 
423
        int pid;
 
424
        char *home = NULL;
 
425
        
 
426
        if (!context) {
 
427
                errno = EBADF;
 
428
                return NULL;
 
429
        }
 
430
        
 
431
        /* Do not initialise the same client twice */
 
432
        if (context->internal->initialized) {
 
433
                return NULL;
 
434
        }
 
435
        
 
436
        if ((!smbc_getFunctionAuthData(context) &&
 
437
             !smbc_getFunctionAuthDataWithContext(context)) ||
 
438
            smbc_getDebug(context) < 0 ||
 
439
            smbc_getDebug(context) > 100) {
 
440
                
 
441
                errno = EINVAL;
 
442
                return NULL;
 
443
                
 
444
        }
 
445
        
 
446
        if (!SMBC_initialized) {
 
447
                /*
 
448
                 * Do some library-wide intializations the first time we get
 
449
                 * called
 
450
                 */
 
451
                bool conf_loaded = False;
 
452
                TALLOC_CTX *frame = talloc_stackframe();
 
453
                
 
454
                load_case_tables();
 
455
                
 
456
                setup_logging("libsmbclient", True);
 
457
                if (context->internal->debug_stderr) {
 
458
                        dbf = x_stderr;
 
459
                        x_setbuf(x_stderr, NULL);
 
460
                }
 
461
                
 
462
                /* Here we would open the smb.conf file if needed ... */
 
463
                
 
464
                lp_set_in_client(True);
 
465
                
 
466
                home = getenv("HOME");
 
467
                if (home) {
 
468
                        char *conf = NULL;
 
469
                        if (asprintf(&conf, "%s/.smb/smb.conf", home) > 0) {
 
470
                                if (lp_load(conf, True, False, False, True)) {
 
471
                                        conf_loaded = True;
 
472
                                } else {
 
473
                                        DEBUG(5, ("Could not load config file: %s\n",
 
474
                                                  conf));
 
475
                                }
 
476
                                SAFE_FREE(conf);
 
477
                        }
 
478
                }
 
479
                
 
480
                if (!conf_loaded) {
 
481
                        /*
 
482
                         * Well, if that failed, try the get_dyn_CONFIGFILE
 
483
                         * Which points to the standard locn, and if that
 
484
                         * fails, silently ignore it and use the internal
 
485
                         * defaults ...
 
486
                         */
 
487
                        
 
488
                        if (!lp_load(get_dyn_CONFIGFILE(), True, False, False, False)) {
 
489
                                DEBUG(5, ("Could not load config file: %s\n",
 
490
                                          get_dyn_CONFIGFILE()));
 
491
                        } else if (home) {
 
492
                                char *conf;
 
493
                                /*
 
494
                                 * We loaded the global config file.  Now lets
 
495
                                 * load user-specific modifications to the
 
496
                                 * global config.
 
497
                                 */
 
498
                                if (asprintf(&conf,
 
499
                                             "%s/.smb/smb.conf.append",
 
500
                                             home) > 0) {
 
501
                                        if (!lp_load(conf, True, False, False, False)) {
 
502
                                                DEBUG(10,
 
503
                                                      ("Could not append config file: "
 
504
                                                       "%s\n",
 
505
                                                       conf));
 
506
                                        }
 
507
                                        SAFE_FREE(conf);
 
508
                                }
 
509
                        }
 
510
                }
 
511
                
 
512
                load_interfaces();  /* Load the list of interfaces ... */
 
513
                
 
514
                reopen_logs();  /* Get logging working ... */
 
515
                
 
516
                /*
 
517
                 * Block SIGPIPE (from lib/util_sock.c: write())
 
518
                 * It is not needed and should not stop execution
 
519
                 */
 
520
                BlockSignals(True, SIGPIPE);
 
521
                
 
522
                /* Done with one-time initialisation */
 
523
                SMBC_initialized = true;
 
524
                
 
525
                TALLOC_FREE(frame);
 
526
        }
 
527
        
 
528
        if (!smbc_getUser(context)) {
 
529
                /*
 
530
                 * FIXME: Is this the best way to get the user info?
 
531
                 */
 
532
                char *user = getenv("USER");
 
533
                /* walk around as "guest" if no username can be found */
 
534
                if (!user) {
 
535
                        user = SMB_STRDUP("guest");
 
536
                } else {
 
537
                        user = SMB_STRDUP(user);
 
538
                }
 
539
 
 
540
                if (!user) {
 
541
                        errno = ENOMEM;
 
542
                        return NULL;
 
543
                }
 
544
 
 
545
                smbc_setUser(context, user);
 
546
                SAFE_FREE(user);
 
547
 
 
548
                if (!smbc_getUser(context)) {
 
549
                        errno = ENOMEM;
 
550
                        return NULL;
 
551
                }
 
552
        }
 
553
        
 
554
        if (!smbc_getNetbiosName(context)) {
 
555
                /*
 
556
                 * We try to get our netbios name from the config. If that
 
557
                 * fails we fall back on constructing our netbios name from
 
558
                 * our hostname etc
 
559
                 */
 
560
                char *netbios_name;
 
561
                if (global_myname()) {
 
562
                        netbios_name = SMB_STRDUP(global_myname());
 
563
                } else {
 
564
                        /*
 
565
                         * Hmmm, I want to get hostname as well, but I am too
 
566
                         * lazy for the moment
 
567
                         */
 
568
                        pid = sys_getpid();
 
569
                        netbios_name = (char *)SMB_MALLOC(17);
 
570
                        if (!netbios_name) {
 
571
                                errno = ENOMEM;
 
572
                                return NULL;
 
573
                        }
 
574
                        slprintf(netbios_name, 16,
 
575
                                 "smbc%s%d", smbc_getUser(context), pid);
 
576
                }
 
577
 
 
578
                if (!netbios_name) {
 
579
                        errno = ENOMEM;
 
580
                        return NULL;
 
581
                }
 
582
                
 
583
                smbc_setNetbiosName(context, netbios_name);
 
584
                SAFE_FREE(netbios_name);
 
585
 
 
586
                if (!smbc_getNetbiosName(context)) {
 
587
                        errno = ENOMEM;
 
588
                        return NULL;
 
589
                }
 
590
        }
 
591
        
 
592
        DEBUG(1, ("Using netbios name %s.\n", smbc_getNetbiosName(context)));
 
593
        
 
594
        if (!smbc_getWorkgroup(context)) {
 
595
                char *workgroup;
 
596
 
 
597
                if (lp_workgroup()) {
 
598
                        workgroup = SMB_STRDUP(lp_workgroup());
 
599
                }
 
600
                else {
 
601
                        /* TODO: Think about a decent default workgroup */
 
602
                        workgroup = SMB_STRDUP("samba");
 
603
                }
 
604
 
 
605
                if (!workgroup) {
 
606
                        errno = ENOMEM;
 
607
                        return NULL;
 
608
                }
 
609
 
 
610
                smbc_setWorkgroup(context, workgroup);
 
611
                SAFE_FREE(workgroup);
 
612
 
 
613
                if (!smbc_getWorkgroup(context)) {
 
614
                        errno = ENOMEM;
 
615
                        return NULL;
 
616
                }
 
617
        }
 
618
        
 
619
        DEBUG(1, ("Using workgroup %s.\n", smbc_getWorkgroup(context)));
 
620
        
 
621
        /* shortest timeout is 1 second */
 
622
        if (smbc_getTimeout(context) > 0 && smbc_getTimeout(context) < 1000)
 
623
                smbc_setTimeout(context, 1000);
 
624
        
 
625
        /*
 
626
         * FIXME: Should we check the function pointers here?
 
627
         */
 
628
        
 
629
        context->internal->initialized = True;
 
630
        initialized_ctx_count++;
 
631
 
 
632
        return context;
 
633
}
 
634
 
 
635
 
 
636
/* Return the verion of samba, and thus libsmbclient */
 
637
const char *
 
638
smbc_version(void)
 
639
{
 
640
        return samba_version_string();
 
641
}
 
642
 
 
643
/*
 
644
 * Set the credentials so DFS will work when following referrals.
 
645
 * This function is broken and must be removed. No SMBCCTX arg...
 
646
 * JRA.
 
647
 */
 
648
 
 
649
void
 
650
smbc_set_credentials(const char *workgroup,
 
651
                        const char *user,
 
652
                        const char *password,
 
653
                        smbc_bool use_kerberos,
 
654
                        const char *signing_state)
 
655
{
 
656
        d_printf("smbc_set_credentials is obsolete. Replace with smbc_set_credentials_with_fallback().\n");
 
657
}
 
658
 
 
659
void smbc_set_credentials_with_fallback(SMBCCTX *context,
 
660
                                        const char *workgroup,
 
661
                                        const char *user,
 
662
                                        const char *password)
 
663
{
 
664
        smbc_bool use_kerberos = false;
 
665
        const char *signing_state = "off";
 
666
        struct user_auth_info *auth_info = NULL;
 
667
 
 
668
        if (! context) {
 
669
 
 
670
                return;
 
671
        }
 
672
 
 
673
        if (! workgroup || ! *workgroup) {
 
674
                workgroup = smbc_getWorkgroup(context);
 
675
        }
 
676
 
 
677
        if (! user) {
 
678
                user = smbc_getUser(context);
 
679
        }
 
680
 
 
681
        if (! password) {
 
682
                password = "";
 
683
        }
 
684
 
 
685
        auth_info = user_auth_info_init(NULL);
 
686
 
 
687
        if (! auth_info) {
 
688
                DEBUG(0, ("smbc_set_credentials_with_fallback: allocation fail\n"));
 
689
                return;
 
690
        }
 
691
 
 
692
        if (smbc_getOptionUseKerberos(context)) {
 
693
                use_kerberos = True;
 
694
        }
 
695
 
 
696
        if (lp_client_signing()) {
 
697
                signing_state = "on";
 
698
        }
 
699
 
 
700
        if (lp_client_signing() == Required) {
 
701
                signing_state = "force";
 
702
        }
 
703
 
 
704
        set_cmdline_auth_info_username(auth_info, user);
 
705
        set_cmdline_auth_info_password(auth_info, password);
 
706
        set_cmdline_auth_info_use_kerberos(auth_info, use_kerberos);
 
707
        set_cmdline_auth_info_signing_state(auth_info, signing_state);
 
708
        set_cmdline_auth_info_fallback_after_kerberos(auth_info,
 
709
                smbc_getOptionFallbackAfterKerberos(context));
 
710
        set_global_myworkgroup(workgroup);
 
711
 
 
712
        TALLOC_FREE(context->internal->auth_info);
 
713
 
 
714
        context->internal->auth_info = auth_info;
 
715
}