/*
* Authentication callback for libsmbclient
*/
static void get_auth_data_with_context_fn(SMBCCTX *smb_ctx,
const char *srv,
const char *shr,
char *wg, int wglen,
char *un, int unlen,
char *pw, int pwlen)
{
static int try_krb5 = 1;
char *h;
(void) smb_ctx;
(void) shr;
(void) wg;
(void) wglen;
DEBUG_SMB(("csync_smb - user=%s, workgroup=%s, server=%s, share=%s\n",
un, wg, srv, shr));
/* Don't authenticate for workgroup listing */
if (srv == NULL || srv[0] == '\0') {
DEBUG_SMB(("csync_smb - emtpy server name"));
return;
}
/* Try kerberos authentication if available */
if (try_krb5 && getenv("KRB5CCNAME")) {
try_krb5 = 0;
return;
}
/* check for an existing user */
h = smbc_getUser(smb_ctx);
if (h != NULL) {
/* The username is known from the url. */
DEBUG_SMB(("csync_smb - have username from url: %s\n", h));
if (snprintf(un, unlen, "%s", h) < 0) {
/* Even if that fials, go on. */
}
} else {
if (_authcb != NULL) {
DEBUG_SMB(("csync_smb - execute authentication callback\n"));
(*_authcb) ("Username:"******"Password:"******"csync_smb - user=%s, workgroup=%s, server=%s, share=%s\n",
un, wg, srv, shr));
try_krb5 = 1;
return;
}
SMBCFILE *
SMBC_open_ctx(SMBCCTX *context,
const char *fname,
int flags,
mode_t mode)
{
char *server = NULL;
char *share = NULL;
char *user = NULL;
char *password = NULL;
char *workgroup = NULL;
char *path = NULL;
char *targetpath = NULL;
struct cli_state *targetcli = NULL;
SMBCSRV *srv = NULL;
SMBCFILE *file = NULL;
uint16_t fd;
uint16_t port = 0;
NTSTATUS status = NT_STATUS_OBJECT_PATH_INVALID;
TALLOC_CTX *frame = talloc_stackframe();
if (!context || !context->internal->initialized) {
errno = EINVAL; /* Best I can think of ... */
TALLOC_FREE(frame);
return NULL;
}
if (!fname) {
errno = EINVAL;
TALLOC_FREE(frame);
return NULL;
}
if (SMBC_parse_path(frame,
context,
fname,
&workgroup,
&server,
&port,
&share,
&path,
&user,
&password,
NULL)) {
errno = EINVAL;
TALLOC_FREE(frame);
return NULL;
}
if (!user || user[0] == (char)0) {
user = talloc_strdup(frame, smbc_getUser(context));
if (!user) {
errno = ENOMEM;
TALLOC_FREE(frame);
return NULL;
}
}
srv = SMBC_server(frame, context, True,
server, port, share, &workgroup, &user, &password);
if (!srv) {
if (errno == EPERM) errno = EACCES;
TALLOC_FREE(frame);
return NULL; /* SMBC_server sets errno */
}
/* Hmmm, the test for a directory is suspect here ... FIXME */
if (strlen(path) > 0 && path[strlen(path) - 1] == '\\') {
status = NT_STATUS_OBJECT_PATH_INVALID;
} else {
file = SMB_MALLOC_P(SMBCFILE);
if (!file) {
errno = ENOMEM;
TALLOC_FREE(frame);
return NULL;
}
ZERO_STRUCTP(file);
/*d_printf(">>>open: resolving %s\n", path);*/
status = cli_resolve_path(
frame, "", context->internal->auth_info,
srv->cli, path, &targetcli, &targetpath);
if (!NT_STATUS_IS_OK(status)) {
d_printf("Could not resolve %s\n", path);
errno = ENOENT;
SAFE_FREE(file);
TALLOC_FREE(frame);
return NULL;
}
/*d_printf(">>>open: resolved %s as %s\n", path, targetpath);*/
status = cli_open(targetcli, targetpath, flags,
context->internal->share_mode, &fd);
if (!NT_STATUS_IS_OK(status)) {
/* Handle the error ... */
SAFE_FREE(file);
errno = SMBC_errno(context, targetcli);
TALLOC_FREE(frame);
return NULL;
}
/* Fill in file struct */
file->cli_fd = fd;
file->fname = SMB_STRDUP(fname);
file->srv = srv;
file->offset = 0;
file->file = True;
/*
* targetcli is either equal to srv->cli or
* is a subsidiary DFS connection. Either way
* file->cli_fd belongs to it so we must cache
* it for read/write/close, not re-resolve each time.
* Re-resolving is both slow and incorrect.
*/
file->targetcli = targetcli;
DLIST_ADD(context->internal->files, file);
/*
* If the file was opened in O_APPEND mode, all write
* operations should be appended to the file. To do that,
* though, using this protocol, would require a getattrE()
* call for each and every write, to determine where the end
* of the file is. (There does not appear to be an append flag
* in the protocol.) Rather than add all of that overhead of
* retrieving the current end-of-file offset prior to each
* write operation, we'll assume that most append operations
* will continuously write, so we'll just set the offset to
* the end of the file now and hope that's adequate.
*
* Note to self: If this proves inadequate, and O_APPEND
* should, in some cases, be forced for each write, add a
* field in the context options structure, for
* "strict_append_mode" which would select between the current
* behavior (if FALSE) or issuing a getattrE() prior to each
* write and forcing the write to the end of the file (if
* TRUE). Adding that capability will likely require adding
* an "append" flag into the _SMBCFILE structure to track
* whether a file was opened in O_APPEND mode. -- djl
*/
if (flags & O_APPEND) {
if (SMBC_lseek_ctx(context, file, 0, SEEK_END) < 0) {
(void) SMBC_close_ctx(context, file);
errno = ENXIO;
TALLOC_FREE(frame);
return NULL;
}
}
TALLOC_FREE(frame);
return file;
}
/* Check if opendir needed ... */
if (!NT_STATUS_IS_OK(status)) {
int eno = 0;
eno = SMBC_errno(context, srv->cli);
file = smbc_getFunctionOpendir(context)(context, fname);
if (!file) errno = eno;
TALLOC_FREE(frame);
return file;
}
errno = EINVAL; /* FIXME, correct errno ? */
TALLOC_FREE(frame);
return NULL;
}
int
SMBC_stat_ctx(SMBCCTX *context,
const char *fname,
struct stat *st)
{
SMBCSRV *srv = NULL;
char *server = NULL;
char *share = NULL;
char *user = NULL;
char *password = NULL;
char *workgroup = NULL;
char *path = NULL;
struct timespec write_time_ts;
struct timespec access_time_ts;
struct timespec change_time_ts;
SMB_OFF_T size = 0;
uint16 mode = 0;
SMB_INO_T ino = 0;
TALLOC_CTX *frame = talloc_stackframe();
if (!context || !context->internal->initialized) {
errno = EINVAL; /* Best I can think of ... */
TALLOC_FREE(frame);
return -1;
}
if (!fname) {
errno = EINVAL;
TALLOC_FREE(frame);
return -1;
}
DEBUG(4, ("smbc_stat(%s)\n", fname));
if (SMBC_parse_path(frame,
context,
fname,
&workgroup,
&server,
&share,
&path,
&user,
&password,
NULL)) {
errno = EINVAL;
TALLOC_FREE(frame);
return -1;
}
if (!user || user[0] == (char)0) {
user = talloc_strdup(frame, smbc_getUser(context));
if (!user) {
errno = ENOMEM;
TALLOC_FREE(frame);
return -1;
}
}
srv = SMBC_server(frame, context, True,
server, share, &workgroup, &user, &password);
if (!srv) {
TALLOC_FREE(frame);
return -1; /* errno set by SMBC_server */
}
if (!SMBC_getatr(context, srv, path, &mode, &size,
NULL,
&access_time_ts,
&write_time_ts,
&change_time_ts,
&ino)) {
errno = SMBC_errno(context, srv->cli);
TALLOC_FREE(frame);
return -1;
}
st->st_ino = ino;
setup_stat(context, st, fname, size, mode);
st->st_atime = convert_timespec_to_time_t(access_time_ts);
st->st_ctime = convert_timespec_to_time_t(change_time_ts);
st->st_mtime = convert_timespec_to_time_t(write_time_ts);
st->st_dev = srv->dev;
TALLOC_FREE(frame);
return 0;
}
/*
* Free a context
*
* Returns 0 on success. Otherwise returns 1, the SMBCCTX is _not_ freed
* and thus you'll be leaking memory if not handled properly.
*
*/
int
smbc_free_context(SMBCCTX *context,
int shutdown_ctx)
{
if (!context) {
errno = EBADF;
return 1;
}
if (shutdown_ctx) {
SMBCFILE * f;
DEBUG(1,("Performing aggressive shutdown.\n"));
f = context->internal->files;
while (f) {
smbc_getFunctionClose(context)(context, f);
f = f->next;
}
context->internal->files = NULL;
/* First try to remove the servers the nice way. */
if (smbc_getFunctionPurgeCachedServers(context)(context)) {
SMBCSRV * s;
SMBCSRV * next;
DEBUG(1, ("Could not purge all servers, "
"Nice way shutdown failed.\n"));
s = context->internal->servers;
while (s) {
DEBUG(1, ("Forced shutdown: %p (fd=%d)\n",
s, s->cli->fd));
cli_shutdown(s->cli);
smbc_getFunctionRemoveCachedServer(context)(context,
s);
next = s->next;
DLIST_REMOVE(context->internal->servers, s);
SAFE_FREE(s);
s = next;
}
context->internal->servers = NULL;
}
}
else {
/* This is the polite way */
if (smbc_getFunctionPurgeCachedServers(context)(context)) {
DEBUG(1, ("Could not purge all servers, "
"free_context failed.\n"));
errno = EBUSY;
return 1;
}
if (context->internal->servers) {
DEBUG(1, ("Active servers in context, "
"free_context failed.\n"));
errno = EBUSY;
return 1;
}
if (context->internal->files) {
DEBUG(1, ("Active files in context, "
"free_context failed.\n"));
errno = EBUSY;
return 1;
}
}
/* Things we have to clean up */
free(smbc_getWorkgroup(context));
smbc_setWorkgroup(context, NULL);
free(smbc_getNetbiosName(context));
smbc_setNetbiosName(context, NULL);
free(smbc_getUser(context));
smbc_setUser(context, NULL);
DEBUG(3, ("Context %p successfully freed\n", context));
/* Free any DFS auth context. */
TALLOC_FREE(context->internal->auth_info);
SAFE_FREE(context->internal);
SAFE_FREE(context);
/* Protect access to the count of contexts in use */
if (SMB_THREAD_LOCK(initialized_ctx_count_mutex) != 0) {
smb_panic("error locking 'initialized_ctx_count'");
}
if (initialized_ctx_count) {
initialized_ctx_count--;
}
if (initialized_ctx_count == 0) {
SMBC_module_terminate();
}
/* Unlock the mutex */
if (SMB_THREAD_UNLOCK(initialized_ctx_count_mutex) != 0) {
smb_panic("error unlocking 'initialized_ctx_count'");
}
return 0;
}
int
SMBC_unlink_print_job_ctx(SMBCCTX *context,
const char *fname,
int id)
{
SMBCSRV *srv = NULL;
char *server = NULL;
char *share = NULL;
char *user = NULL;
char *password = NULL;
char *workgroup = NULL;
char *path = NULL;
int err;
TALLOC_CTX *frame = talloc_stackframe();
if (!context || !context->internal->initialized) {
errno = EINVAL;
TALLOC_FREE(frame);
return -1;
}
if (!fname) {
errno = EINVAL;
TALLOC_FREE(frame);
return -1;
}
DEBUG(4, ("smbc_unlink_print_job(%s)\n", fname));
if (SMBC_parse_path(frame,
context,
fname,
&workgroup,
&server,
&share,
&path,
&user,
&password,
NULL)) {
errno = EINVAL;
TALLOC_FREE(frame);
return -1;
}
if (!user || user[0] == (char)0) {
user = talloc_strdup(frame, smbc_getUser(context));
if (!user) {
errno = ENOMEM;
TALLOC_FREE(frame);
return -1;
}
}
srv = SMBC_server(frame, context, True,
server, share, &workgroup, &user, &password);
if (!srv) {
TALLOC_FREE(frame);
return -1; /* errno set by SMBC_server */
}
if ((err = cli_printjob_del(srv->cli, id)) != 0) {
if (err < 0)
errno = SMBC_errno(context, srv->cli);
else if (err == ERRnosuchprintjob)
errno = EINVAL;
TALLOC_FREE(frame);
return -1;
}
TALLOC_FREE(frame);
return 0;
}
int
SMBC_list_print_jobs_ctx(SMBCCTX *context,
const char *fname,
smbc_list_print_job_fn fn)
{
SMBCSRV *srv = NULL;
char *server = NULL;
char *share = NULL;
char *user = NULL;
char *password = NULL;
char *workgroup = NULL;
char *path = NULL;
TALLOC_CTX *frame = talloc_stackframe();
if (!context || !context->internal->initialized) {
errno = EINVAL;
TALLOC_FREE(frame);
return -1;
}
if (!fname) {
errno = EINVAL;
TALLOC_FREE(frame);
return -1;
}
DEBUG(4, ("smbc_list_print_jobs(%s)\n", fname));
if (SMBC_parse_path(frame,
context,
fname,
&workgroup,
&server,
&share,
&path,
&user,
&password,
NULL)) {
errno = EINVAL;
TALLOC_FREE(frame);
return -1;
}
if (!user || user[0] == (char)0) {
user = talloc_strdup(frame, smbc_getUser(context));
if (!user) {
errno = ENOMEM;
TALLOC_FREE(frame);
return -1;
}
}
srv = SMBC_server(frame, context, True,
server, share, &workgroup, &user, &password);
if (!srv) {
TALLOC_FREE(frame);
return -1; /* errno set by SMBC_server */
}
if (cli_print_queue(srv->cli,
(void (*)(struct print_job_info *))fn) < 0) {
errno = SMBC_errno(context, srv->cli);
TALLOC_FREE(frame);
return -1;
}
TALLOC_FREE(frame);
return 0;
}
/*
* Free a context
*
* Returns 0 on success. Otherwise returns 1, the SMBCCTX is _not_ freed
* and thus you'll be leaking memory if not handled properly.
*
*/
int
smbc_free_context(SMBCCTX *context,
int shutdown_ctx)
{
if (!context) {
errno = EBADF;
return 1;
}
if (shutdown_ctx) {
SMBCFILE * f;
DEBUG(1,("Performing aggressive shutdown.\n"));
f = context->internal->files;
while (f) {
smbc_getFunctionClose(context)(context, f);
f = f->next;
}
context->internal->files = NULL;
/* First try to remove the servers the nice way. */
if (smbc_getFunctionPurgeCachedServers(context)(context)) {
SMBCSRV * s;
SMBCSRV * next;
DEBUG(1, ("Could not purge all servers, "
"Nice way shutdown failed.\n"));
s = context->internal->servers;
while (s) {
DEBUG(1, ("Forced shutdown: %p (fd=%d)\n",
s, s->cli->fd));
cli_shutdown(s->cli);
smbc_getFunctionRemoveCachedServer(context)(context,
s);
next = s->next;
DLIST_REMOVE(context->internal->servers, s);
SAFE_FREE(s);
s = next;
}
context->internal->servers = NULL;
}
}
else {
/* This is the polite way */
if (smbc_getFunctionPurgeCachedServers(context)(context)) {
DEBUG(1, ("Could not purge all servers, "
"free_context failed.\n"));
errno = EBUSY;
return 1;
}
if (context->internal->servers) {
DEBUG(1, ("Active servers in context, "
"free_context failed.\n"));
errno = EBUSY;
return 1;
}
if (context->internal->files) {
DEBUG(1, ("Active files in context, "
"free_context failed.\n"));
errno = EBUSY;
return 1;
}
}
/* Things we have to clean up */
free(smbc_getWorkgroup(context));
smbc_setWorkgroup(context, NULL);
free(smbc_getNetbiosName(context));
smbc_setNetbiosName(context, NULL);
free(smbc_getUser(context));
smbc_setUser(context, NULL);
DEBUG(3, ("Context %p successfully freed\n", context));
SAFE_FREE(context->internal);
SAFE_FREE(context);
if (initialized_ctx_count) {
initialized_ctx_count--;
}
if (initialized_ctx_count == 0 && SMBC_initialized) {
gencache_shutdown();
secrets_shutdown();
gfree_all();
SMBC_initialized = false;
}
return 0;
}
