GetTimeOfDay(&tp_start);
if (lowercase) {
- strlower(lname);
+ strlower(discard_const_p(char, lname));
}
fnum = smbcli_open(cli->tree, rname, O_RDONLY, DENY_NONE);
pstrcat(cur_dir,finfo->name);
pstrcat(cur_dir,"\\");
- string_replace(finfo->name, '\\', '/');
- if (lowercase)
- strlower(finfo->name);
+ string_replace(discard_const_p(char, finfo->name), '\\', '/');
+ if (lowercase) {
+ strlower(discard_const_p(char, finfo->name));
+ }
if (!directory_exist(finfo->name,NULL) &&
mkdir(finfo->name,0777) != 0) {
/****************************************************************************
try and browse available connections on a host
****************************************************************************/
-static BOOL list_servers(char *wk_grp)
+static BOOL list_servers(const char *wk_grp)
{
d_printf("REWRITE: list servers not implemented\n");
return False;
/****************************************************************************
make sure we swallow keepalives during idle time
****************************************************************************/
-static void readline_callback(const char **cmd_ptr)
+static void readline_callback(void)
{
static time_t last_t;
time_t t;
/**
Convert list of tokens to array; dependent on above routine.
- Uses last_ptr from above - bit of a hack.
**/
-
-static char **toktocliplist(const char *ptr, int *ctok, const char *sep)
+static char **toktocliplist(char *ptr, int *ctok, const char *sep)
{
char *s = ptr;
int ictok=0;
static void writetarheader(int f, const char *aname, uint64_t size, time_t mtime,
const char *amode, uint8_t ftype);
-static void do_atar(char *rname,char *lname,file_info *finfo1);
+static void do_atar(char *rname,const char *lname,file_info *finfo1);
static void do_tar(file_info *finfo);
static void oct_it(uint64_t value, int ndgs, char *p);
static void fixtarname(char *tptr, const char *fp, int l);
/****************************************************************************
append one remote file to the tar file
***************************************************************************/
-static void do_atar(char *rname,char *lname,file_info *finfo1)
+static void do_atar(char *rname,const char *lname,file_info *finfo1)
{
int fnum;
uint64_t nread=0;
finfo.mtime = finfo1 -> mtime;
finfo.atime = finfo1 -> atime;
finfo.ctime = finfo1 -> ctime;
- finfo.name = finfo1 -> name;
+ finfo.name = discard_const_p(char, finfo1 -> name);
}
else {
ZERO_STRUCT(finfo);
/****************************************************************************
Principal command for creating / extracting
***************************************************************************/
-int cmd_tar(const char **cmd_ptr)
+int cmd_tar(char **cmd_ptr)
{
fstring buf;
char **argl;
int argcl;
- if (!next_token(cmd_ptr,buf,NULL,sizeof(buf)))
+ if (!next_token((const char **)cmd_ptr,buf,NULL,sizeof(buf)))
{
DEBUG(0,("tar <c|x>[IXbgan] <filename>\n"));
return 1;
****************************************************************************/
static char *smb_readline_replacement(const char *prompt, void (*callback)(void),
- char **(completion_fn)(const char *text, int start, int end))
+ char **(completion_fn)(const char *text, int start, int end))
{
fd_set fds;
static pstring line;
LDAPMessage *ldapres, *msg;
lldb->last_rc = ldap_search_s(lldb->ldap, base, (int)scope,
- expression, attrs, 0, &ldapres);
+ expression,
+ discard_const_p(char *, attrs),
+ 0, &ldapres);
if (lldb->last_rc != LDAP_SUCCESS) {
return -1;
}
}
-static int ldb_close_registry(void *data)
-{
- ldb_close((struct ldb_context *)data);
- return 0;
-}
-
static WERROR ldb_get_subkey_by_id(TALLOC_CTX *mem_ctx, struct registry_key *k, int idx, struct registry_key **subkey)
{
struct ldb_context *c = k->hive->backend_data;
if(tmp->data_type == REG_SZ) {
char *ret;
- dat_len = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, dtmp, dat_len, (const void **)&ret);
+ dat_len = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, dtmp, dat_len, (void **)&ret);
dtmp = ret;
}
#endif
-static WERROR nt_close_registry (struct registry_hive *h)
-{
- REGF *regf = h->backend_data;
- if (regf->base) munmap(regf->base, regf->sbuf.st_size);
- regf->base = NULL;
- close(regf->fd); /* Ignore the error :-) */
-
- return WERR_OK;
-}
-
static WERROR nt_open_hive (TALLOC_CTX *mem_ctx, struct registry_hive *h, struct registry_key **key)
{
REGF *regf;
static WERROR rpc_open_hive(TALLOC_CTX *mem_ctx, struct registry_hive *h, struct registry_key **k)
{
NTSTATUS status;
- char *user, *pass;
+ char *user;
+ char *pass;
struct rpc_key_data *mykeydata;
struct dcerpc_pipe *p;
int n;
user = talloc_strdup(mem_ctx, h->credentials);
pass = strchr(user, '%');
- if(pass)
- {
- *pass = '\0'; pass++;
+ if (pass) {
+ pass = strdup(pass+1);
} else {
- pass = "";
+ pass = strdup("");
}
status = dcerpc_pipe_connect(&p, h->location,
- DCERPC_WINREG_UUID,
- DCERPC_WINREG_VERSION,
- lp_workgroup(),
- user, pass);
+ DCERPC_WINREG_UUID,
+ DCERPC_WINREG_VERSION,
+ lp_workgroup(),
+ user, pass);
+ free(pass);
h->backend_data = p;
return known_hives[n].open((struct dcerpc_pipe *)h->backend_data, *k, &(mykeydata->pol));
}
-static WERROR rpc_close_registry(struct registry_hive *h)
-{
- dcerpc_pipe_close((struct dcerpc_pipe *)h->backend_data);
- return WERR_OK;
-}
-
+#if 0
static WERROR rpc_key_put_rpc_data(TALLOC_CTX *mem_ctx, struct registry_key *k)
{
struct winreg_OpenKey r;
return r.out.result;
}
-
+#endif
static WERROR rpc_open_rel_key(TALLOC_CTX *mem_ctx, struct registry_key *h, const char *name, struct registry_key **key)
{
return WERR_NO_MORE_ITEMS;
}
-static WERROR w95_close_reg(struct registry_hive *h)
-{
- CREG *creg = h->backend_data;
- if (creg->base) munmap(creg->base, creg->sbuf.st_size);
- creg->base = NULL;
- close(creg->fd);
- return WERR_OK;
-}
-
static WERROR w95_num_values(struct registry_key *k, int *count)
{
RGKN_KEY *rgkn_key = k->backend_data;
tm->tm_sec);
}
-
+/*
+ a hack to move the stupid gcc strftime warning to one place - see manual page
+*/
+#ifdef HAVE_STRFTIME
+size_t sys_strftime(char *s, size_t max, const char *fmt, const struct tm *tm)
+{
+ return strftime(s, max, fmt, tm);
+}
+#endif
/****************************************************************************
Return the date and time as a string
in the gcc warning, not a bug in this code. See a recent
strftime() manual page for details.
*/
- strftime(tempTime,sizeof(tempTime)-1,"%c %Z",tm);
+ sys_strftime(tempTime,sizeof(tempTime)-1,"%c %Z",tm);
TimeBuf = talloc_strdup(mem_ctx, tempTime);
#else
TimeBuf = talloc_strdup(mem_ctx, asctime(tm));
switch(spnego->type) {
case SPNEGO_NEG_TOKEN_INIT:
if (spnego->negTokenInit.mechTypes) {
- int i;
- for (i = 0; spnego->negTokenInit.mechTypes[i]; i++) {
- talloc_free(spnego->negTokenInit.mechTypes[i]);
- }
talloc_free(spnego->negTokenInit.mechTypes);
}
data_blob_free(&spnego->negTokenInit.mechToken);
BOOL winbind_off( void )
{
- static char *s = WINBINDD_DONT_ENV "=1";
-
+#if HAVE_SETENV
+ setenv(WINBINDD_DONT_ENV, "1", 1);
+ return True;
+#else
+ static const char *s = WINBINDD_DONT_ENV "=1";
return putenv(s) != -1;
+#endif
}
BOOL winbind_on( void )
{
- static char *s = WINBINDD_DONT_ENV "=0";
-
+#if HAVE_SETENV
+ setenv(WINBINDD_DONT_ENV, "0", 1);
+ return True;
+#else
+ static const char *s = WINBINDD_DONT_ENV "=0";
return putenv(s) != -1;
+#endif
}
struct pvfs_filename *name, union smb_fileinfo *info)
{
switch (info->generic.level) {
+ case RAW_FILEINFO_GENERIC:
+ return NT_STATUS_INVALID_LEVEL;
+
case RAW_FILEINFO_GETATTR:
info->getattr.out.attrib = name->dos.attrib;
info->getattr.out.size = name->st.st_size;
{
ssize_t ret;
- CHECK_READ_ONLY(req);
+ if (wr->generic.level != RAW_WRITE_WRITEX) {
+ return ntvfs_map_write(req, wr, ntvfs);
+ }
- switch (wr->generic.level) {
- case RAW_WRITE_WRITEX:
- ret = pwrite(wr->writex.in.fnum,
- wr->writex.in.data,
- wr->writex.in.count,
- wr->writex.in.offset);
- if (ret == -1) {
- return map_nt_error_from_unix(errno);
- }
-
- wr->writex.out.nwritten = ret;
- wr->writex.out.remaining = 0; /* should fill this in? */
-
- return NT_STATUS_OK;
-
- case RAW_WRITE_WRITE:
- if (wr->write.in.count == 0) {
- /* a truncate! */
- ret = ftruncate(wr->write.in.fnum, wr->write.in.offset);
- } else {
- ret = pwrite(wr->write.in.fnum,
- wr->write.in.data,
- wr->write.in.count,
- wr->write.in.offset);
- }
- if (ret == -1) {
- return map_nt_error_from_unix(errno);
- }
-
- wr->write.out.nwritten = ret;
+ CHECK_READ_ONLY(req);
- return NT_STATUS_OK;
+ ret = pwrite(wr->writex.in.fnum,
+ wr->writex.in.data,
+ wr->writex.in.count,
+ wr->writex.in.offset);
+ if (ret == -1) {
+ return map_nt_error_from_unix(errno);
}
-
- return NT_STATUS_NOT_SUPPORTED;
+
+ wr->writex.out.nwritten = ret;
+ wr->writex.out.remaining = 0; /* should fill this in? */
+
+ return NT_STATUS_OK;
}
/*
DATA_BLOB *session_key)
{
/* this took quite a few CPU cycles to find ... */
- session_key->data = "SystemLibraryDTC";
+ session_key->data = discard_const_p(char, "SystemLibraryDTC");
session_key->length = 16;
return NT_STATUS_OK;
}
-static void sigcont(void)
+static void sigcont(int sig)
{
}
ZERO_ARRAY(timestr);
tm = localtime(&r.generic.out.time);
- strftime(timestr, sizeof(timestr)-1, "%c %Z",tm);
+ sys_strftime(timestr, sizeof(timestr)-1, "%c %Z",tm);
printf("%s\n",timestr);