o_len=destlen;
retval = smb_iconv(descriptor, &inbuf, &i_len, &outbuf, &o_len);
if(retval==(size_t)-1) {
- const char *reason="unknown error";
+ const char *reason;
switch(errno) {
case EINVAL:
reason="Incomplete multibyte sequence";
a blocking lock on SIGALRM.
***************************************************************/
-static sig_atomic_t *palarm_fired;
+static SIG_ATOMIC_T *palarm_fired;
-void tdb_set_lock_alarm(sig_atomic_t *palarm)
+void tdb_set_lock_alarm(SIG_ATOMIC_T *palarm)
{
palarm_fired = palarm;
}
void tdb_unlockall(TDB_CONTEXT *tdb);
/* Low level locking functions: use with care */
-void tdb_set_lock_alarm(sig_atomic_t *palarm);
+void tdb_set_lock_alarm(SIG_ATOMIC_T *palarm);
int tdb_chainlock(TDB_CONTEXT *tdb, TDB_DATA key);
int tdb_chainunlock(TDB_CONTEXT *tdb, TDB_DATA key);
char *get_socket_name(TALLOC_CTX *mem_ctx, int fd, BOOL force_lookup)
{
char *name_buf;
- char *addr_buf;
struct hostent *hp;
struct in_addr addr;
char *p;
name_buf = talloc_strdup(mem_ctx, "UNKNOWN");
if (fd == -1) return name_buf;
- addr_buf = talloc_strdup(mem_ctx, p);
-
addr = *interpret_addr2(mem_ctx, p);
/* Look up the remote host name. */
}
}
- alpha_strcpy(name_buf, name_buf, "_-.", sizeof(name_buf));
+ alpha_strcpy(name_buf, name_buf, "_-.", strlen(name_buf)+1);
if (strstr(name_buf,"..")) {
name_buf = talloc_strdup(mem_ctx, "UNKNOWN");
}
**/
static BOOL string_init(char **dest,const char *src)
{
- size_t l;
if (!src) src = "";
- l = strlen(src);
-
(*dest) = strdup(src);
if ((*dest) == NULL) {
DEBUG(0,("Out of memory in string_init\n"));
const smb_ucs2_t *strstr_w(const smb_ucs2_t *s, const smb_ucs2_t *ins)
{
const smb_ucs2_t *r;
- size_t slen, inslen;
+ size_t inslen;
if (!s || !*s || !ins || !*ins) return NULL;
- slen = strlen_w(s);
inslen = strlen_w(ins);
r = s;
while ((r = strchr_w(r, *ins))) {
const smb_ucs2_t *strstr_wa(const smb_ucs2_t *s, const char *ins)
{
const smb_ucs2_t *r;
- size_t slen, inslen;
+ size_t inslen;
if (!s || !*s || !ins || !*ins) return NULL;
- slen = strlen_w(s);
inslen = strlen(ins);
r = s;
while ((r = strchr_w(r, UCS2_CHAR(*ins)))) {
char *out;
uuid_unpack(in, &uu);
- if (!out) return NULL;
out = talloc_asprintf(mem_ctx,
"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
uu.time_low, uu.time_mid, uu.time_hi_and_version,
int wct = 14 + parms->in.setup_count;
struct cli_request *req;
char *outdata,*outparam;
- int data_sent, param_sent;
int i;
const int padding = 3;
}
/* fill in SMB parameters */
- data_sent = parms->in.data.length;
- param_sent = parms->in.params.length;
outparam = req->out.data + padding;
- outdata = outparam + param_sent;
+ outdata = outparam + parms->in.params.length;
/* make sure we don't leak data via the padding */
memset(req->out.data, 0, padding);
#if ZERO_ZERO
/* sort the lock list */
- qsort(dbuf.dptr, dbuf.dsize/sizeof(lock), sizeof(lock), lock_compare);
+ qsort(dbuf.dptr, dbuf.dsize/sizeof(lock), sizeof(lock), QSORT_CAST lock_compare);
#endif
tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
in hash order. */
qsort(tstruct.queue, tstruct.qcount, sizeof(print_queue_struct),
- QSORT_CAST(printjob_comp));
+ QSORT_CAST printjob_comp);
*queue = tstruct.queue;
return tstruct.qcount;
a blocking lock on SIGALRM.
***************************************************************/
-static sig_atomic_t *palarm_fired;
+static SIG_ATOMIC_T *palarm_fired;
-void tdb_set_lock_alarm(sig_atomic_t *palarm)
+void tdb_set_lock_alarm(SIG_ATOMIC_T *palarm)
{
palarm_fired = palarm;
}
void tdb_unlockall(TDB_CONTEXT *tdb);
/* Low level locking functions: use with care */
-void tdb_set_lock_alarm(sig_atomic_t *palarm);
+void tdb_set_lock_alarm(SIG_ATOMIC_T *palarm);
int tdb_chainlock(TDB_CONTEXT *tdb, TDB_DATA key);
int tdb_chainunlock(TDB_CONTEXT *tdb, TDB_DATA key);
static fstring password;
static fstring username;
-static int got_pass;
static int max_protocol = PROTOCOL_NT1;
static BOOL showall = False;
static BOOL old_list = False;
if (p) {
*p = 0;
fstrcpy(password, p+1);
- got_pass = 1;
}
break;
case 's':
void nb_flush(int fnum)
{
+ struct smb_flush io;
int i;
i = find_handle(fnum);
- /* hmmm, we don't have cli_flush() yet */
+ io.in.fnum = ftable[i].fd;
+ smb_raw_flush(c->tree, &io);
}
void nb_deltree(const char *dname)
CHECK_STATUS(status, NT_STATUS_OK);
done:
+ cli_close(cli, fnum);
smb_raw_exit(cli->session);
cli_deltree(cli, BASEDIR);
return ret;
CHECK_VALUE(result.count, num_files);
if (search_types[t].level == RAW_SEARCH_BOTH_DIRECTORY_INFO) {
- qsort(result.list, result.count, sizeof(result.list[0]), search_both_compare);
+ qsort(result.list, result.count, sizeof(result.list[0]),
+ QSORT_CAST search_both_compare);
} else if (search_types[t].level == RAW_SEARCH_STANDARD) {
- qsort(result.list, result.count, sizeof(result.list[0]), search_standard_compare);
+ qsort(result.list, result.count, sizeof(result.list[0]),
+ QSORT_CAST search_standard_compare);
} else {
- qsort(result.list, result.count, sizeof(result.list[0]), search_old_compare);
+ qsort(result.list, result.count, sizeof(result.list[0]),
+ QSORT_CAST search_old_compare);
}
for (i=0;i<num_files;i++) {
static BOOL use_level_II_oplocks;
static const char *client_txt = "client_oplocks.txt";
static BOOL use_kerberos;
-static BOOL bypass_io;
BOOL torture_showall = False;
{
int opt, i;
char *p;
- int gotuser = 0;
BOOL correct = True;
char *host, *share, *username;
srandom(time(NULL));
- while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:e:m:Ld:Ac:ks:f:bs:")) != EOF) {
+ while ((opt = getopt(argc, argv, "p:hW:U:n:N:O:o:e:m:Ld:Ac:ks:f:s:")) != EOF) {
switch (opt) {
case 'p':
lp_set_cmdline("smb ports", optarg);
#endif
break;
case 'U':
- gotuser = 1;
parse_user(optarg);
break;
case 'f':
torture_failures = atoi(optarg);
break;
- case 'b':
- bypass_io = True;
- break;
-
+
default:
printf("Unknown option %c (%d)\n", (char)opt, opt);
usage();
}
str_list_free(&lang_list);
- qsort(pl, lang_num, sizeof(struct pri_list), &qsort_cmp_list);
+ qsort(pl, lang_num, sizeof(struct pri_list), QSORT_CAST qsort_cmp_list);
/* it's not an error to not initialise - we just fall back to
the default */
Catch a sighup.
****************************************************************************/
-VOLATILE sig_atomic_t reload_after_sighup = False;
+VOLATILE SIG_ATOMIC_T reload_after_sighup = False;
static void sig_hup(int sig)
{