From ba332083a4e3c2c186ff715bd27ffdaee162e4a3 Mon Sep 17 00:00:00 2001 From: Olaf Barthel Date: Sun, 27 Mar 2016 18:11:12 +0200 Subject: [PATCH] Cleaned up the indentation --- source_code/proc.c | 3561 ++++++++++++++++++++++---------------------- 1 file changed, 1779 insertions(+), 1782 deletions(-) diff --git a/source_code/proc.c b/source_code/proc.c index 8c5e709..ba6d0dc 100644 --- a/source_code/proc.c +++ b/source_code/proc.c @@ -1,7 +1,5 @@ /* - * $Id: proc.c,v 1.9 2009/07/22 07:52:59 obarthel Exp $ - * - * :ts=8 + * :ts=4 * * proc.c * @@ -24,14 +22,14 @@ /*****************************************************************************/ -#define SMB_VWV(packet) ((packet) + SMB_HEADER_LEN) -#define SMB_CMD(packet) ((packet)[8]) -#define SMB_WCT(packet) ((packet)[SMB_HEADER_LEN - 1]) -#define SMB_BCC(packet) smb_bcc(packet) -#define SMB_BUF(packet) ((packet) + SMB_HEADER_LEN + SMB_WCT(packet) * 2 + 2) +#define SMB_VWV(packet) ((packet) + SMB_HEADER_LEN) +#define SMB_CMD(packet) ((packet)[8]) +#define SMB_WCT(packet) ((packet)[SMB_HEADER_LEN - 1]) +#define SMB_BCC(packet) smb_bcc(packet) +#define SMB_BUF(packet) ((packet) + SMB_HEADER_LEN + SMB_WCT(packet) * 2 + 2) -#define SMB_DIRINFO_SIZE 43 -#define SMB_STATUS_SIZE 21 +#define SMB_DIRINFO_SIZE 43 +#define SMB_STATUS_SIZE 21 /*****************************************************************************/ @@ -71,104 +69,104 @@ static void smb_printerr(int class, int num); static INLINE byte * smb_encode_word (byte * p, word data) { - p[0] = data & 0x00ffU; - p[1] = (data & 0xff00U) >> 8; - return &p[2]; + p[0] = data & 0x00ffU; + p[1] = (data & 0xff00U) >> 8; + return &p[2]; } static INLINE byte * smb_decode_word (byte * p, word * data) { - (*data) = (word) (p[0] | ((word)p[1]) << 8); - return &(p[2]); + (*data) = (word) (p[0] | ((word)p[1]) << 8); + return &(p[2]); } byte * smb_encode_smb_length (byte * p, dword len) { - p[0] = p[1] = 0; - p[2] = (len & 0xFF00) >> 8; - p[3] = (len & 0xFF); + p[0] = p[1] = 0; + p[2] = (len & 0xFF00) >> 8; + p[3] = (len & 0xFF); - if (len > 0xFFFF) - p[1] |= 0x01; + if (len > 0xFFFF) + p[1] |= 0x01; - return &p[4]; + return &p[4]; } static byte * smb_encode_dialect (byte * p, const byte * name, int len) { - (*p++) = 2; - strcpy (p, name); + (*p++) = 2; + strcpy (p, name); - return p + len + 1; + return p + len + 1; } static byte * smb_encode_ascii (byte * p, const byte * name, int len) { - (*p++) = 4; - strcpy (p, name); + (*p++) = 4; + strcpy (p, name); - return p + len + 1; + return p + len + 1; } static void smb_encode_vblock (byte * p, const byte * data, word len, int unused_fs) { - (*p++) = 5; - p = smb_encode_word (p, len); - memcpy (p, data, len); + (*p++) = 5; + p = smb_encode_word (p, len); + memcpy (p, data, len); } static byte * smb_decode_data (byte * p, byte * data, word * data_len, int unused_fs) { - word len; + word len; - if (!((*p) == 1 || (*p) == 5)) - LOG (("Warning! Data block not starting with 1 or 5\n")); + if (!((*p) == 1 || (*p) == 5)) + LOG (("Warning! Data block not starting with 1 or 5\n")); - len = WVAL (p, 1); - p += 3; + len = WVAL (p, 1); + p += 3; - memcpy (data, p, len); + memcpy (data, p, len); - (*data_len) = len; + (*data_len) = len; - return p + len; + return p + len; } static byte * smb_name_mangle (byte * p, const byte * name) { - int len, pad = 0; + int len, pad = 0; - len = strlen (name); + len = strlen (name); - if (len < 16) - pad = 16 - len; + if (len < 16) + pad = 16 - len; - (*p++) = 2 * (len + pad); + (*p++) = 2 * (len + pad); - while ((*name) != '\0') - { - (*p++) = ((*name) >> 4) + 'A'; - (*p++) = ((*name) & 0x0F) + 'A'; + while ((*name) != '\0') + { + (*p++) = ((*name) >> 4) + 'A'; + (*p++) = ((*name) & 0x0F) + 'A'; - name++; - } + name++; + } - while (pad-- > 0) - { - (*p++) = 'C'; - (*p++) = 'A'; - } + while (pad-- > 0) + { + (*p++) = 'C'; + (*p++) = 'A'; + } - (*p++) = '\0'; + (*p++) = '\0'; - return p; + return p; } /* According to the core protocol documentation times are @@ -177,60 +175,60 @@ smb_name_mangle (byte * p, const byte * name) static INLINE int utc2local (int time_value) { - int result; + int result; - if(time_value > 0) - result = time_value - GetTimeZoneDelta(); - else - result = time_value; + if(time_value > 0) + result = time_value - GetTimeZoneDelta(); + else + result = time_value; - return result; + return result; } static INLINE int local2utc (int time_value) { - int result; + int result; - if(time_value > 0) - result = time_value + GetTimeZoneDelta(); - else - result = time_value; + if(time_value > 0) + result = time_value + GetTimeZoneDelta(); + else + result = time_value; - return result; + return result; } /* Convert a MS-DOS time/date pair to a UNIX date (seconds since January 1st 1970). */ static int date_dos2unix (unsigned short time_value, unsigned short date) { - time_t seconds; - struct tm tm; + time_t seconds; + struct tm tm; - memset(&tm,0,sizeof(tm)); + memset(&tm,0,sizeof(tm)); - tm.tm_sec = 2 * (time_value & 0x1F); - tm.tm_min = (time_value >> 5) & 0x3F; - tm.tm_hour = (time_value >> 11) & 0x1F; - tm.tm_mday = date & 0x1F; - tm.tm_mon = ((date >> 5) & 0xF) - 1; - tm.tm_year = ((date >> 9) & 0x7F) + 80; + tm.tm_sec = 2 * (time_value & 0x1F); + tm.tm_min = (time_value >> 5) & 0x3F; + tm.tm_hour = (time_value >> 11) & 0x1F; + tm.tm_mday = date & 0x1F; + tm.tm_mon = ((date >> 5) & 0xF) - 1; + tm.tm_year = ((date >> 9) & 0x7F) + 80; - seconds = MakeTime(&tm); + seconds = MakeTime(&tm); - return(seconds); + return(seconds); } /* Convert linear UNIX date to a MS-DOS time/date pair. */ static void date_unix2dos (int unix_date, unsigned short *time_value, unsigned short *date) { - struct tm tm; + struct tm tm; - GMTime(unix_date,&tm); + GMTime(unix_date,&tm); - (*time_value) = (tm.tm_hour << 11) | (tm.tm_min << 5) | (tm.tm_sec / 2); - (*date) = ((tm.tm_year - 80) << 9) | ((tm.tm_mon + 1) << 5) | tm.tm_mday; + (*time_value) = (tm.tm_hour << 11) | (tm.tm_min << 5) | (tm.tm_sec / 2); + (*date) = ((tm.tm_year - 80) << 9) | ((tm.tm_mon + 1) << 5) | tm.tm_mday; } /**************************************************************************** @@ -241,15 +239,15 @@ date_unix2dos (int unix_date, unsigned short *time_value, unsigned short *date) dword smb_len (byte * packet) { - return (dword)( (((dword)(packet[1] & 0x1)) << 16) | (((dword)packet[2]) << 8) | (packet[3]) ); + return (dword)( (((dword)(packet[1] & 0x1)) << 16) | (((dword)packet[2]) << 8) | (packet[3]) ); } static INLINE word smb_bcc (byte * packet) { - int pos = SMB_HEADER_LEN + SMB_WCT (packet) * sizeof (word); + int pos = SMB_HEADER_LEN + SMB_WCT (packet) * sizeof (word); - return (word)(packet[pos] | ((word)packet[pos + 1]) << 8); + return (word)(packet[pos] | ((word)packet[pos + 1]) << 8); } /* smb_valid_packet: We check if packet fulfills the basic @@ -257,9 +255,9 @@ smb_bcc (byte * packet) static INLINE int smb_valid_packet (byte * packet) { - int result; + int result; - LOG (("len: %ld, wct: %ld, bcc: %ld -- SMB_HEADER_LEN[%ld] + SMB_WCT (packet) * 2[%ld] + SMB_BCC (packet)[%ld] + 2 = %ld\n", + LOG (("len: %ld, wct: %ld, bcc: %ld -- SMB_HEADER_LEN[%ld] + SMB_WCT (packet) * 2[%ld] + SMB_BCC (packet)[%ld] + 2 = %ld\n", smb_len (packet), SMB_WCT (packet), SMB_BCC (packet), @@ -268,18 +266,18 @@ smb_valid_packet (byte * packet) SMB_BCC (packet), SMB_HEADER_LEN + SMB_WCT (packet) * 2 + SMB_BCC (packet) + 2)); - /* olsen: During protocol negotiation Samba 3.2.5 may return SMB responses which contain - more data than is called for. I'm not sure what the right approach to handle - this would be. But for now, I've modified this test to check only if there - is less data in a response than required. */ - result = (packet[4] == 0xff - && packet[5] == 'S' - && packet[6] == 'M' - && packet[7] == 'B' - && (smb_len (packet) + 4 >= (dword) - (SMB_HEADER_LEN + SMB_WCT (packet) * 2 + SMB_BCC (packet) + 2))) ? 0 : (-EIO); + /* olsen: During protocol negotiation Samba 3.2.5 may return SMB responses which contain + more data than is called for. I'm not sure what the right approach to handle + this would be. But for now, I've modified this test to check only if there + is less data in a response than required. */ + result = (packet[4] == 0xff + && packet[5] == 'S' + && packet[6] == 'M' + && packet[7] == 'B' + && (smb_len (packet) + 4 >= (dword) + (SMB_HEADER_LEN + SMB_WCT (packet) * 2 + SMB_BCC (packet) + 2))) ? 0 : (-EIO); - return result; + return result; } /* smb_verify: We check if we got the answer we expected, and if we @@ -287,118 +285,117 @@ smb_valid_packet (byte * packet) static INLINE int smb_verify (byte * packet, int command, int wct, int bcc) { - return (SMB_CMD (packet) == command && - SMB_WCT (packet) >= wct && - (bcc == -1 || SMB_BCC (packet) >= bcc)) ? 0 : -EIO; + return (SMB_CMD (packet) == command && + SMB_WCT (packet) >= wct && + (bcc == -1 || SMB_BCC (packet) >= bcc)) ? 0 : -EIO; } static int smb_errno (int errcls, int error) { - int result,i; + int result,i; - if (errcls) - smb_printerr (errcls, error); + if (errcls) + smb_printerr (errcls, error); - if (errcls == ERRDOS) - { - static const int map[][2] = - { - { ERRbadfunc,EINVAL }, - { ERRbadfile,ENOENT }, - { ERRbadpath,ENOENT }, - { ERRnofids,EMFILE }, - { ERRnoaccess,EACCES }, - { ERRbadfid,EBADF }, - { ERRbadmcb,EIO }, - { ERRnomem,ENOMEM }, - { ERRbadmem,EFAULT }, - { ERRbadenv,EIO }, - { ERRbadformat,EIO }, - { ERRbadaccess,EACCES }, - { ERRbaddata,E2BIG }, - { ERRbaddrive,ENXIO }, - { ERRremcd,EIO }, - { ERRdiffdevice,EXDEV }, - { ERRnofiles,0 }, - { ERRbadshare,ETXTBSY }, - { ERRlock,EDEADLK }, - { ERRfilexists,EEXIST }, - { 87,0 },/* Unknown error! */ - { 183,EEXIST },/* This next error seems to occur on an mv when - the destination exists */ - { -1,-1 } - }; + if (errcls == ERRDOS) + { + static const int map[][2] = + { + { ERRbadfunc,EINVAL }, + { ERRbadfile,ENOENT }, + { ERRbadpath,ENOENT }, + { ERRnofids,EMFILE }, + { ERRnoaccess,EACCES }, + { ERRbadfid,EBADF }, + { ERRbadmcb,EIO }, + { ERRnomem,ENOMEM }, + { ERRbadmem,EFAULT }, + { ERRbadenv,EIO }, + { ERRbadformat,EIO }, + { ERRbadaccess,EACCES }, + { ERRbaddata,E2BIG }, + { ERRbaddrive,ENXIO }, + { ERRremcd,EIO }, + { ERRdiffdevice,EXDEV }, + { ERRnofiles,0 }, + { ERRbadshare,ETXTBSY }, + { ERRlock,EDEADLK }, + { ERRfilexists,EEXIST }, + { 87,0 },/* Unknown error! */ + { 183,EEXIST },/* This next error seems to occur on an mv when the destination exists */ + { -1,-1 } + }; - result = EIO; + result = EIO; - for(i = 0 ; map[i][0] != -1 ; i++) - { - if(map[i][0] == error) - { - result = map[i][1]; - break; - } - } - } - else if (errcls == ERRSRV) - { - static const int map[][2] = - { - { ERRerror,ENFILE }, - { ERRbadpw,EINVAL }, - { ERRbadtype,EIO }, - { ERRaccess,EACCES }, - { -1, -1 } - }; + for(i = 0 ; map[i][0] != -1 ; i++) + { + if(map[i][0] == error) + { + result = map[i][1]; + break; + } + } + } + else if (errcls == ERRSRV) + { + static const int map[][2] = + { + { ERRerror,ENFILE }, + { ERRbadpw,EINVAL }, + { ERRbadtype,EIO }, + { ERRaccess,EACCES }, + { -1, -1 } + }; - result = EIO; + result = EIO; - for(i = 0 ; map[i][0] != -1 ; i++) - { - if(map[i][0] == error) - { - result = map[i][1]; - break; - } - } - } - else if (errcls == ERRHRD) - { - static const int map[][2] = - { - { ERRnowrite,EROFS }, - { ERRbadunit,ENODEV }, - { ERRnotready,EBUSY }, - { ERRbadcmd,EIO }, - { ERRdata,EIO }, - { ERRbadreq,ERANGE }, - { ERRbadshare,ETXTBSY }, - { ERRlock,EDEADLK }, - { -1, -1 } - }; + for(i = 0 ; map[i][0] != -1 ; i++) + { + if(map[i][0] == error) + { + result = map[i][1]; + break; + } + } + } + else if (errcls == ERRHRD) + { + static const int map[][2] = + { + { ERRnowrite,EROFS }, + { ERRbadunit,ENODEV }, + { ERRnotready,EBUSY }, + { ERRbadcmd,EIO }, + { ERRdata,EIO }, + { ERRbadreq,ERANGE }, + { ERRbadshare,ETXTBSY }, + { ERRlock,EDEADLK }, + { -1, -1 } + }; - result = EIO; + result = EIO; - for(i = 0 ; map[i][0] != -1 ; i++) - { - if(map[i][0] == error) - { - result = map[i][1]; - break; - } - } - } - else if (errcls == ERRCMD) - { - result = EIO; - } - else - { - result = 0; - } + for(i = 0 ; map[i][0] != -1 ; i++) + { + if(map[i][0] == error) + { + result = map[i][1]; + break; + } + } + } + else if (errcls == ERRCMD) + { + result = EIO; + } + else + { + result = 0; + } - return(result); + return(result); } #if DEBUG @@ -406,55 +403,55 @@ smb_errno (int errcls, int error) static char print_char (char c) { - if ((c < ' ') || (c > '~')) - return '.'; + if ((c < ' ') || (c > '~')) + return '.'; - return c; + return c; } static void smb_dump_packet (byte * packet) { - int i, j, len; - int errcls, error; + int i, j, len; + int errcls, error; - errcls = (int) packet[9]; - error = (int) (int) (packet[11] | ((int)packet[12]) << 8); + errcls = (int) packet[9]; + error = (int) (int) (packet[11] | ((int)packet[12]) << 8); - LOG (("smb_len = %ld valid = %ld \n", len = smb_len (packet), smb_valid_packet (packet))); - LOG (("smb_cmd = %ld smb_wct = %ld smb_bcc = %ld\n", packet[8], SMB_WCT (packet), SMB_BCC (packet))); - LOG (("smb_rcls = %ld smb_err = %ld\n", errcls, error)); + LOG (("smb_len = %ld valid = %ld\n", len = smb_len (packet), smb_valid_packet (packet))); + LOG (("smb_cmd = %ld smb_wct = %ld smb_bcc = %ld\n", packet[8], SMB_WCT (packet), SMB_BCC (packet))); + LOG (("smb_rcls = %ld smb_err = %ld\n", errcls, error)); - if (errcls) - smb_printerr (errcls, error); + if (errcls) + smb_printerr (errcls, error); - if (len > 100) - len = 100; + if (len > 100) + len = 100; - PRINTHEADER(); + PRINTHEADER(); - for (i = 0; i < len; i += 10) - { - PRINTF (("%03ld:", i)); + for (i = 0; i < len; i += 10) + { + PRINTF (("%03ld:", i)); - for (j = i; j < i + 10; j++) - { - if (j < len) - PRINTF (("%02lx ", packet[j])); - else - PRINTF ((" ")); - } + for (j = i; j < i + 10; j++) + { + if (j < len) + PRINTF (("%02lx ", packet[j])); + else + PRINTF ((" ")); + } - PRINTF ((": ")); + PRINTF ((": ")); - for (j = i; j < i + 10; j++) - { - if (j < len) - PRINTF (("%lc", print_char (packet[j]))); - } + for (j = i; j < i + 10; j++) + { + if (j < len) + PRINTF (("%lc", print_char (packet[j]))); + } - PRINTF (("\n")); - } + PRINTF (("\n")); + } } #endif /* DEBUG */ @@ -466,33 +463,33 @@ smb_dump_packet (byte * packet) static int smb_request_ok (struct smb_server *s, int command, int wct, int bcc) { - int result; - int error; + int result; + int error; - s->rcls = 0; - s->err = 0; + s->rcls = 0; + s->err = 0; - result = smb_request (s); - if (result < 0) - { - LOG (("smb_request failed\n")); - } - else if ((error = smb_valid_packet (s->packet)) != 0) - { - LOG (("not a valid packet!\n")); - result = error; - } - else if (s->rcls != 0) - { - result = -smb_errno (s->rcls, s->err); - } - else if ((error = smb_verify (s->packet, command, wct, bcc)) != 0) - { - LOG (("smb_verify failed\n")); - result = error; - } + result = smb_request (s); + if (result < 0) + { + LOG (("smb_request failed\n")); + } + else if ((error = smb_valid_packet (s->packet)) != 0) + { + LOG (("not a valid packet!\n")); + result = error; + } + else if (s->rcls != 0) + { + result = -smb_errno (s->rcls, s->err); + } + else if ((error = smb_verify (s->packet, command, wct, bcc)) != 0) + { + LOG (("smb_verify failed\n")); + result = error; + } - return(result); + return(result); } /* smb_retry: This function should be called when smb_request_ok has @@ -503,86 +500,86 @@ smb_request_ok (struct smb_server *s, int command, int wct, int bcc) static int smb_retry (struct smb_server *server) { - int result = 0; + int result = 0; - if (server->state == CONN_VALID) - goto out; + if (server->state == CONN_VALID) + goto out; - if (smb_release (server) < 0) - { - LOG (("smb_retry: smb_release failed\n")); - server->state = CONN_RETRIED; - goto out; - } + if (smb_release (server) < 0) + { + LOG (("smb_retry: smb_release failed\n")); + server->state = CONN_RETRIED; + goto out; + } - if (smb_proc_reconnect (server) < 0) - { - LOG (("smb_proc_reconnect failed\n")); - server->state = CONN_RETRIED; - goto out; - } + if (smb_proc_reconnect (server) < 0) + { + LOG (("smb_proc_reconnect failed\n")); + server->state = CONN_RETRIED; + goto out; + } - server->state = CONN_VALID; - result = 1; + server->state = CONN_VALID; + result = 1; out: - return result; + return result; } static int smb_request_ok_unlock (struct smb_server *s, int command, int wct, int bcc) { - int result; + int result; - result = smb_request_ok (s, command, wct, bcc); + result = smb_request_ok (s, command, wct, bcc); - return result; + return result; } /* smb_setup_header: We completely set up the packet. You only have to - insert the command-specific fields */ + insert the command-specific fields */ static byte * smb_setup_header (struct smb_server *server, byte command, word wct, word bcc) { - dword xmit_len = SMB_HEADER_LEN + wct * sizeof (word) + bcc + 2; - byte *p = server->packet; - byte *buf = server->packet; + dword xmit_len = SMB_HEADER_LEN + wct * sizeof (word) + bcc + 2; + byte *p = server->packet; + byte *buf = server->packet; - /* olsen: we subtract four bytes because smb_encode_smb_length() adds - four bytes which are not supposed to be included in the total - number of bytes to be sent */ - p = smb_encode_smb_length (p, xmit_len - 4); - /* p = smb_encode_smb_length (p, xmit_len); */ + /* olsen: we subtract four bytes because smb_encode_smb_length() adds + four bytes which are not supposed to be included in the total + number of bytes to be sent */ + p = smb_encode_smb_length (p, xmit_len - 4); + /* p = smb_encode_smb_length (p, xmit_len); */ - BSET (p, 0, 0xff); - BSET (p, 1, 'S'); - BSET (p, 2, 'M'); - BSET (p, 3, 'B'); - BSET (p, 4, command); + BSET (p, 0, 0xff); + BSET (p, 1, 'S'); + BSET (p, 2, 'M'); + BSET (p, 3, 'B'); + BSET (p, 4, command); - p += 5; - memset (p, '\0', 19); - p += 19; - memset (p, '\0', 8); /* zap the signature */ - p += 8; + p += 5; + memset (p, '\0', 19); + p += 19; + memset (p, '\0', 8); /* zap the signature */ + p += 8; - WSET (buf, smb_tid, server->tid); - WSET (buf, smb_pid, 0); /* server->pid */ - WSET (buf, smb_uid, server->server_uid); - WSET (buf, smb_mid, 0); /* server->mid */ + WSET (buf, smb_tid, server->tid); + WSET (buf, smb_pid, 0); /* server->pid */ + WSET (buf, smb_uid, server->server_uid); + WSET (buf, smb_mid, 0); /* server->mid */ - if (server->protocol > PROTOCOL_CORE) - { - BSET (buf, smb_flg, 0x8); /* path names are caseless */ - WSET (buf, smb_flg2, 0x3); /* extended attributes supported, long names supported */ - } + if (server->protocol > PROTOCOL_CORE) + { + BSET (buf, smb_flg, 0x8); /* path names are caseless */ + WSET (buf, smb_flg2, 0x3); /* extended attributes supported, long names supported */ + } - (*p++) = wct; /* wct */ - p += 2 * wct; - WSET (p, 0, bcc); + (*p++) = wct; /* wct */ + p += 2 * wct; + WSET (p, 0, bcc); - return p + 2; + return p + 2; } /* smb_setup_header_exclusive waits on server->lock and locks the @@ -591,11 +588,11 @@ smb_setup_header (struct smb_server *server, byte command, word wct, word bcc) static byte * smb_setup_header_exclusive (struct smb_server *server, byte command, word wct, word bcc) { - byte * result; + byte * result; - result = smb_setup_header (server, command, wct, bcc); + result = smb_setup_header (server, command, wct, bcc); - return result; + return result; } /***************************************************************************** @@ -607,70 +604,70 @@ smb_setup_header_exclusive (struct smb_server *server, byte command, word wct, w int smb_proc_open (struct smb_server *server, const char *pathname, int len, struct smb_dirent *entry) { - int error; - char *p; - char *buf = server->packet; - const word o_attr = aSYSTEM | aHIDDEN | aDIR; + int error; + char *p; + char *buf = server->packet; + const word o_attr = aSYSTEM | aHIDDEN | aDIR; - LOG (("path=%s\n", pathname)); + LOG (("path=%s\n", pathname)); retry: - p = smb_setup_header (server, SMBopen, 2, 2 + len); - WSET (buf, smb_vwv0, 0x42); /* read/write */ - WSET (buf, smb_vwv1, o_attr); - smb_encode_ascii (p, pathname, len); + p = smb_setup_header (server, SMBopen, 2, 2 + len); + WSET (buf, smb_vwv0, 0x42); /* read/write */ + WSET (buf, smb_vwv1, o_attr); + smb_encode_ascii (p, pathname, len); - if ((error = smb_request_ok (server, SMBopen, 7, 0)) < 0) - { - if (smb_retry (server)) - goto retry; + if ((error = smb_request_ok (server, SMBopen, 7, 0)) < 0) + { + if (smb_retry (server)) + goto retry; - if (error != -EACCES) - goto out; + if (error != -EACCES) + goto out; - p = smb_setup_header (server, SMBopen, 2, 2 + len); - WSET (buf, smb_vwv0, 0x40); /* read only */ - WSET (buf, smb_vwv1, o_attr); - smb_encode_ascii (p, pathname, len); + p = smb_setup_header (server, SMBopen, 2, 2 + len); + WSET (buf, smb_vwv0, 0x40); /* read only */ + WSET (buf, smb_vwv1, o_attr); + smb_encode_ascii (p, pathname, len); - if ((error = smb_request_ok (server, SMBopen, 7, 0)) < 0) - { - if (smb_retry (server)) - goto retry; + if ((error = smb_request_ok (server, SMBopen, 7, 0)) < 0) + { + if (smb_retry (server)) + goto retry; - goto out; - } - } + goto out; + } + } - /* We should now have data in vwv[0..6]. */ - entry->fileid = WVAL (buf, smb_vwv0); - entry->attr = WVAL (buf, smb_vwv1); - entry->ctime = entry->atime = entry->mtime = entry->wtime = local2utc (DVAL (buf, smb_vwv2)); - entry->size = DVAL (buf, smb_vwv4); - entry->opened = 1; + /* We should now have data in vwv[0..6]. */ + entry->fileid = WVAL (buf, smb_vwv0); + entry->attr = WVAL (buf, smb_vwv1); + entry->ctime = entry->atime = entry->mtime = entry->wtime = local2utc (DVAL (buf, smb_vwv2)); + entry->size = DVAL (buf, smb_vwv4); + entry->opened = 1; - #if DEBUG - { - struct tm tm; + #if DEBUG + { + struct tm tm; - GMTime(entry->ctime,&tm); - LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(entry->ctime,&tm); + LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(entry->atime,&tm); - LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(entry->atime,&tm); + LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(entry->mtime,&tm); - LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(entry->mtime,&tm); + LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(entry->wtime,&tm); - LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - } - #endif /* DEBUG */ + GMTime(entry->wtime,&tm); + LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + } + #endif /* DEBUG */ out: - return error; + return error; } /* smb_proc_close: in finfo->mtime we can send a modification time to @@ -678,27 +675,27 @@ smb_proc_open (struct smb_server *server, const char *pathname, int len, struct int smb_proc_close (struct smb_server *server, word fileid, dword mtime) { - char *buf = server->packet; - int local_time; - int result; + char *buf = server->packet; + int local_time; + int result; - if(mtime != 0 && mtime != 0xffffffff) - { - /* 0 and 0xffffffff mean: do not set mtime */ - local_time = utc2local (mtime); - } - else - { - local_time = mtime; - } + if(mtime != 0 && mtime != 0xffffffff) + { + /* 0 and 0xffffffff mean: do not set mtime */ + local_time = utc2local (mtime); + } + else + { + local_time = mtime; + } - smb_setup_header_exclusive (server, SMBclose, 3, 0); - WSET (buf, smb_vwv0, fileid); - DSET (buf, smb_vwv1, local_time); + smb_setup_header_exclusive (server, SMBclose, 3, 0); + WSET (buf, smb_vwv0, fileid); + DSET (buf, smb_vwv1, local_time); - result = smb_request_ok_unlock (server, SMBclose, 0, 0); + result = smb_request_ok_unlock (server, SMBclose, 0, 0); - return result; + return result; } /* In smb_proc_read and smb_proc_write we do not retry, because the @@ -709,570 +706,570 @@ smb_proc_close (struct smb_server *server, word fileid, dword mtime) int smb_proc_read (struct smb_server *server, struct smb_dirent *finfo, off_t offset, long count, char *data, int fs) { - word returned_count, data_len; - char *buf = server->packet; - int result; - int error; + word returned_count, data_len; + char *buf = server->packet; + int result; + int error; - smb_setup_header_exclusive (server, SMBread, 5, 0); + smb_setup_header_exclusive (server, SMBread, 5, 0); - WSET (buf, smb_vwv0, finfo->fileid); - WSET (buf, smb_vwv1, count); - DSET (buf, smb_vwv2, offset); - WSET (buf, smb_vwv4, 0); + WSET (buf, smb_vwv0, finfo->fileid); + WSET (buf, smb_vwv1, count); + DSET (buf, smb_vwv2, offset); + WSET (buf, smb_vwv4, 0); - if ((error = smb_request_ok (server, SMBread, 5, -1)) < 0) - { - result = error; - goto out; - } + if ((error = smb_request_ok (server, SMBread, 5, -1)) < 0) + { + result = error; + goto out; + } - returned_count = WVAL (buf, smb_vwv0); + returned_count = WVAL (buf, smb_vwv0); - smb_decode_data (SMB_BUF (server->packet), data, &data_len, fs); + smb_decode_data (SMB_BUF (server->packet), data, &data_len, fs); - if (returned_count != data_len) - { - LOG (("Warning, returned_count != data_len\n")); - LOG (("ret_c=%ld, data_len=%ld\n", returned_count, data_len)); - } - else - { - LOG (("ret_c=%ld, data_len=%ld\n", returned_count, data_len)); - } + if (returned_count != data_len) + { + LOG (("Warning, returned_count != data_len\n")); + LOG (("ret_c=%ld, data_len=%ld\n", returned_count, data_len)); + } + else + { + LOG (("ret_c=%ld, data_len=%ld\n", returned_count, data_len)); + } - result = data_len; + result = data_len; out: - return result; + return result; } -/* count must be <= 65535. No error number is returned. A result of 0 +/* count must be <= 65535. No error number is returned. A result of 0 indicates an error, which has to be investigated by a normal read call. */ int smb_proc_read_raw (struct smb_server *server, struct smb_dirent *finfo, off_t offset, long count, char *data) { - char *buf = server->packet; - int result; + char *buf = server->packet; + int result; - smb_setup_header_exclusive (server, SMBreadbraw, 8, 0); + smb_setup_header_exclusive (server, SMBreadbraw, 8, 0); - WSET (buf, smb_vwv0, finfo->fileid); - DSET (buf, smb_vwv1, offset); - WSET (buf, smb_vwv3, count); /* maxcnt */ - WSET (buf, smb_vwv4, 0); /* mincnt */ - DSET (buf, smb_vwv5, 0); /* timeout */ + WSET (buf, smb_vwv0, finfo->fileid); + DSET (buf, smb_vwv1, offset); + WSET (buf, smb_vwv3, count); /* maxcnt */ + WSET (buf, smb_vwv4, 0); /* mincnt */ + DSET (buf, smb_vwv5, 0); /* timeout */ - result = smb_request_read_raw (server, data, count); + result = smb_request_read_raw (server, data, count); - return result; + return result; } int smb_proc_write (struct smb_server *server, struct smb_dirent *finfo, off_t offset, long count, const char *data) { - int res; - char *buf = server->packet; - byte *p; + int res; + char *buf = server->packet; + byte *p; - p = smb_setup_header_exclusive (server, SMBwrite, 5, count + 3); - WSET (buf, smb_vwv0, finfo->fileid); - WSET (buf, smb_vwv1, count); - DSET (buf, smb_vwv2, offset); - WSET (buf, smb_vwv4, 0); + p = smb_setup_header_exclusive (server, SMBwrite, 5, count + 3); + WSET (buf, smb_vwv0, finfo->fileid); + WSET (buf, smb_vwv1, count); + DSET (buf, smb_vwv2, offset); + WSET (buf, smb_vwv4, 0); - (*p++) = 1; - WSET (p, 0, count); - memcpy (p + 2, data, count); + (*p++) = 1; + WSET (p, 0, count); + memcpy (p + 2, data, count); - if ((res = smb_request_ok (server, SMBwrite, 1, 0)) >= 0) - res = WVAL (buf, smb_vwv0); + if ((res = smb_request_ok (server, SMBwrite, 1, 0)) >= 0) + res = WVAL (buf, smb_vwv0); - return res; + return res; } /* count must be <= 65535 */ int smb_proc_write_raw (struct smb_server *server, struct smb_dirent *finfo, off_t offset, long count, const char *data) { - char *buf = server->packet; - int result; - long len = server->max_xmit - 4; - byte *p; + char *buf = server->packet; + int result; + long len = server->max_xmit - 4; + byte *p; - if (len >= count) - len = 0; - else - len = count - len; /* transfer the larger part using the second packet */ + if (len >= count) + len = 0; + else + len = count - len; /* transfer the larger part using the second packet */ - p = smb_setup_header_exclusive (server, SMBwritebraw, server->protocol > PROTOCOL_COREPLUS ? 12 : 11, len); + p = smb_setup_header_exclusive (server, SMBwritebraw, server->protocol > PROTOCOL_COREPLUS ? 12 : 11, len); - WSET (buf, smb_vwv0, finfo->fileid); - DSET (buf, smb_vwv1, count); - DSET (buf, smb_vwv3, offset); - DSET (buf, smb_vwv5, 0); /* timeout */ - WSET (buf, smb_vwv7, 1); /* send final result response */ - DSET (buf, smb_vwv8, 0); /* reserved */ + WSET (buf, smb_vwv0, finfo->fileid); + DSET (buf, smb_vwv1, count); + DSET (buf, smb_vwv3, offset); + DSET (buf, smb_vwv5, 0); /* timeout */ + WSET (buf, smb_vwv7, 1); /* send final result response */ + DSET (buf, smb_vwv8, 0); /* reserved */ - if (server->protocol > PROTOCOL_COREPLUS) - { - WSET (buf, smb_vwv10, len); - WSET (buf, smb_vwv11, p - smb_base(buf)); - } + if (server->protocol > PROTOCOL_COREPLUS) + { + WSET (buf, smb_vwv10, len); + WSET (buf, smb_vwv11, p - smb_base(buf)); + } - if (len > 0) - memcpy (p, data, len); + if (len > 0) + memcpy (p, data, len); - result = smb_request_ok (server, SMBwritebraw, 1, 0); + result = smb_request_ok (server, SMBwritebraw, 1, 0); - LOG (("first request returned %ld\n", result)); + LOG (("first request returned %ld\n", result)); - if (result < 0) - goto out; + if (result < 0) + goto out; - result = smb_request_write_raw (server, data + len, count - len); + result = smb_request_write_raw (server, data + len, count - len); - LOG(("raw request returned %ld\n", result)); + LOG(("raw request returned %ld\n", result)); - if (result > 0) - { - int error; + if (result > 0) + { + int error; - /* We have to do the checks of smb_request_ok here as well */ - if ((error = smb_valid_packet (server->packet)) != 0) - { - LOG (("not a valid packet!\n")); - result = error; - } - else if (server->rcls != 0) - { - result = -smb_errno (server->rcls, server->err); - } - else if ((error = smb_verify (server->packet, SMBwritec, 1, 0)) != 0) - { - LOG (("smb_verify failed\n")); - result = error; - } + /* We have to do the checks of smb_request_ok here as well */ + if ((error = smb_valid_packet (server->packet)) != 0) + { + LOG (("not a valid packet!\n")); + result = error; + } + else if (server->rcls != 0) + { + result = -smb_errno (server->rcls, server->err); + } + else if ((error = smb_verify (server->packet, SMBwritec, 1, 0)) != 0) + { + LOG (("smb_verify failed\n")); + result = error; + } - /* If everything went fine, the whole block has been transfered. */ - if (result == (count - len)) - result = count; - } + /* If everything went fine, the whole block has been transfered. */ + if (result == (count - len)) + result = count; + } out: - return result; + return result; } int smb_proc_lseek (struct smb_server *server, struct smb_dirent *finfo, off_t offset, int mode, off_t * new_position_ptr) { - char *buf = server->packet; - int error; + char *buf = server->packet; + int error; retry: - smb_setup_header (server, SMBlseek, 4,0); + smb_setup_header (server, SMBlseek, 4,0); - WSET (buf, smb_vwv0, finfo->fileid); - WSET (buf, smb_vwv1, mode); - DSET (buf, smb_vwv2, offset); + WSET (buf, smb_vwv0, finfo->fileid); + WSET (buf, smb_vwv1, mode); + DSET (buf, smb_vwv2, offset); - if ((error = smb_request_ok (server, SMBlseek, 1, 0)) < 0) - { - if (smb_retry (server)) - goto retry; - } - else - { - (*new_position_ptr) = DVAL(buf, smb_vwv0); - } + if ((error = smb_request_ok (server, SMBlseek, 1, 0)) < 0) + { + if (smb_retry (server)) + goto retry; + } + else + { + (*new_position_ptr) = DVAL(buf, smb_vwv0); + } - return error; + return error; } -/* smb_proc_lockingX: We don't chain any further packets to the initial one */ +/* smb_proc_lockingX: We don't chain any further packets to the initial one */ int smb_proc_lockingX (struct smb_server *server, struct smb_dirent *finfo, struct smb_lkrng *locks, int num_entries, int mode, long timeout) { - int result; - int num_locks, num_unlocks; - char *buf = server->packet; - char *data; - struct smb_lkrng *p; - int i; + int result; + int num_locks, num_unlocks; + char *buf = server->packet; + char *data; + struct smb_lkrng *p; + int i; - num_locks = num_unlocks = 0; + num_locks = num_unlocks = 0; - if (mode & 2) - num_unlocks = num_entries; - else - num_locks = num_entries; + if (mode & 2) + num_unlocks = num_entries; + else + num_locks = num_entries; retry: - data = smb_setup_header(server, SMBlockingX, 8, num_entries * 10); + data = smb_setup_header(server, SMBlockingX, 8, num_entries * 10); - BSET (buf, smb_vwv0, 0xFF); - WSET (buf, smb_vwv1, 0); - WSET (buf, smb_vwv2, finfo->fileid); - BSET (buf, smb_vwv3, mode & 1); - DSET (buf, smb_vwv4, timeout); - WSET (buf, smb_vwv6, num_unlocks); - WSET (buf, smb_vwv7, num_locks); + BSET (buf, smb_vwv0, 0xFF); + WSET (buf, smb_vwv1, 0); + WSET (buf, smb_vwv2, finfo->fileid); + BSET (buf, smb_vwv3, mode & 1); + DSET (buf, smb_vwv4, timeout); + WSET (buf, smb_vwv6, num_unlocks); + WSET (buf, smb_vwv7, num_locks); - for (i = 0, p = locks; i < num_entries; i++, p++) - { - WSET (data, SMB_LPID_OFFSET(i), 0); /* server->pid */ - DSET (data, SMB_LKOFF_OFFSET(i), p->offset); - DSET (data, SMB_LKLEN_OFFSET(i), p->len); - } + for (i = 0, p = locks; i < num_entries; i++, p++) + { + WSET (data, SMB_LPID_OFFSET(i), 0); /* server->pid */ + DSET (data, SMB_LKOFF_OFFSET(i), p->offset); + DSET (data, SMB_LKLEN_OFFSET(i), p->len); + } - if ((result = smb_request_ok (server, SMBlockingX, 0, 0)) < 0) - { - if (smb_retry (server)) - goto retry; - } - - return result; + if ((result = smb_request_ok (server, SMBlockingX, 0, 0)) < 0) + { + if (smb_retry (server)) + goto retry; + } + + return result; } /* smb_proc_do_create: We expect entry->attry & entry->ctime to be set. */ static int smb_proc_do_create (struct smb_server *server, const char *path, int len, struct smb_dirent *entry, word command) { - int error; - char *p; - char *buf = server->packet; - int local_time; + int error; + char *p; + char *buf = server->packet; + int local_time; retry: - p = smb_setup_header (server, command, 3, len + 2); - WSET (buf, smb_vwv0, entry->attr); - local_time = utc2local (entry->ctime); - DSET (buf, smb_vwv1, local_time); - smb_encode_ascii (p, path, len); + p = smb_setup_header (server, command, 3, len + 2); + WSET (buf, smb_vwv0, entry->attr); + local_time = utc2local (entry->ctime); + DSET (buf, smb_vwv1, local_time); + smb_encode_ascii (p, path, len); - if ((error = smb_request_ok (server, command, 1, 0)) < 0) - { - if (smb_retry (server)) - goto retry; + if ((error = smb_request_ok (server, command, 1, 0)) < 0) + { + if (smb_retry (server)) + goto retry; - goto out; - } + goto out; + } - entry->opened = 1; - entry->fileid = WVAL (buf, smb_vwv0); + entry->opened = 1; + entry->fileid = WVAL (buf, smb_vwv0); - smb_proc_close (server, entry->fileid, entry->mtime); + smb_proc_close (server, entry->fileid, entry->mtime); out: - return error; + return error; } int smb_proc_create (struct smb_server *server, const char *path, int len, struct smb_dirent *entry) { - return smb_proc_do_create (server, path, len, entry, SMBcreate); + return smb_proc_do_create (server, path, len, entry, SMBcreate); } int smb_proc_mv (struct smb_server *server, const char *opath, const int olen, const char *npath, const int nlen) { - char *p; - char *buf = server->packet; - int result; + char *p; + char *buf = server->packet; + int result; retry: - p = smb_setup_header (server, SMBmv, 1, olen + nlen + 4); + p = smb_setup_header (server, SMBmv, 1, olen + nlen + 4); - WSET (buf, smb_vwv0, 0); + WSET (buf, smb_vwv0, 0); - p = smb_encode_ascii (p, opath, olen); - smb_encode_ascii (p, npath, olen); + p = smb_encode_ascii (p, opath, olen); + smb_encode_ascii (p, npath, olen); - if ((result = smb_request_ok (server, SMBmv, 0, 0)) < 0) - { - if (smb_retry (server)) - goto retry; - } + if ((result = smb_request_ok (server, SMBmv, 0, 0)) < 0) + { + if (smb_retry (server)) + goto retry; + } - return result; + return result; } int smb_proc_mkdir (struct smb_server *server, const char *path, const int len) { - char *p; - int result; + char *p; + int result; retry: - p = smb_setup_header (server, SMBmkdir, 0, 2 + len); + p = smb_setup_header (server, SMBmkdir, 0, 2 + len); - smb_encode_ascii (p, path, len); + smb_encode_ascii (p, path, len); - if ((result = smb_request_ok (server, SMBmkdir, 0, 0)) < 0) - { - if (smb_retry (server)) - goto retry; - } + if ((result = smb_request_ok (server, SMBmkdir, 0, 0)) < 0) + { + if (smb_retry (server)) + goto retry; + } - return result; + return result; } int smb_proc_rmdir (struct smb_server *server, const char *path, const int len) { - char *p; - int result; + char *p; + int result; retry: - p = smb_setup_header (server, SMBrmdir, 0, 2 + len); + p = smb_setup_header (server, SMBrmdir, 0, 2 + len); - smb_encode_ascii (p, path, len); + smb_encode_ascii (p, path, len); - if ((result = smb_request_ok (server, SMBrmdir, 0, 0)) < 0) - { - if (smb_retry (server)) - goto retry; - } + if ((result = smb_request_ok (server, SMBrmdir, 0, 0)) < 0) + { + if (smb_retry (server)) + goto retry; + } - return result; + return result; } int smb_proc_unlink (struct smb_server *server, const char *path, const int len) { - char *p; - char *buf = server->packet; - int result; + char *p; + char *buf = server->packet; + int result; retry: - p = smb_setup_header (server, SMBunlink, 1, 2 + len); + p = smb_setup_header (server, SMBunlink, 1, 2 + len); - WSET (buf, smb_vwv0, 0); + WSET (buf, smb_vwv0, 0); - smb_encode_ascii (p, path, len); + smb_encode_ascii (p, path, len); - if ((result = smb_request_ok (server, SMBunlink, 0, 0)) < 0) - { - if (smb_retry (server)) - goto retry; - } + if ((result = smb_request_ok (server, SMBunlink, 0, 0)) < 0) + { + if (smb_retry (server)) + goto retry; + } - return result; + return result; } int smb_proc_trunc (struct smb_server *server, word fid, dword length) { - char *p; - char *buf = server->packet; - int result; + char *p; + char *buf = server->packet; + int result; - p = smb_setup_header (server, SMBwrite, 5, 3); - WSET (buf, smb_vwv0, fid); - WSET (buf, smb_vwv1, 0); - DSET (buf, smb_vwv2, length); - WSET (buf, smb_vwv4, 0); - smb_encode_ascii (p, "", 0); + p = smb_setup_header (server, SMBwrite, 5, 3); + WSET (buf, smb_vwv0, fid); + WSET (buf, smb_vwv1, 0); + DSET (buf, smb_vwv2, length); + WSET (buf, smb_vwv4, 0); + smb_encode_ascii (p, "", 0); - result = smb_request_ok (server, SMBwrite, 1, 0); - if (result >= 0) - result = DVAL(buf, smb_vwv0); + result = smb_request_ok (server, SMBwrite, 1, 0); + if (result >= 0) + result = DVAL(buf, smb_vwv0); - return result; + return result; } static char * smb_decode_dirent (char *p, struct smb_dirent *entry) { - size_t name_size; + size_t name_size; - p += SMB_STATUS_SIZE; /* reserved (search_status) */ + p += SMB_STATUS_SIZE; /* reserved (search_status) */ - entry->attr = BVAL (p, 0); - entry->mtime = entry->atime = entry->ctime = entry->wtime = date_dos2unix (WVAL (p, 1), WVAL (p, 3)); - entry->size = DVAL (p, 5); + entry->attr = BVAL (p, 0); + entry->mtime = entry->atime = entry->ctime = entry->wtime = date_dos2unix (WVAL (p, 1), WVAL (p, 3)); + entry->size = DVAL (p, 5); - name_size = 13; + name_size = 13; - if(name_size > entry->complete_path_size-1) - name_size = entry->complete_path_size-1; + if(name_size > entry->complete_path_size-1) + name_size = entry->complete_path_size-1; - memcpy (entry->complete_path, p + 9, name_size); + memcpy (entry->complete_path, p + 9, name_size); - entry->complete_path[name_size] = '\0'; + entry->complete_path[name_size] = '\0'; - LOG (("smb_decode_dirent: path = %s\n", entry->complete_path)); + LOG (("smb_decode_dirent: path = %s\n", entry->complete_path)); - #if DEBUG - { - struct tm tm; + #if DEBUG + { + struct tm tm; - GMTime(entry->ctime,&tm); - LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(entry->ctime,&tm); + LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(entry->atime,&tm); - LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(entry->atime,&tm); + LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(entry->mtime,&tm); - LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(entry->mtime,&tm); + LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(entry->wtime,&tm); - LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - } - #endif /* DEBUG */ + GMTime(entry->wtime,&tm); + LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + } + #endif /* DEBUG */ - return p + 22; + return p + 22; } /* This routine is used to read in directory entries from the network. - Note that it is for short directory name seeks, i.e.: protocol < PROTOCOL_LANMAN2 */ + Note that it is for short directory name seeks, i.e.: protocol < PROTOCOL_LANMAN2 */ static int smb_proc_readdir_short (struct smb_server *server, char *path, int fpos, int cache_size, struct smb_dirent *entry) { - char *p; - char *buf; - int error; - int result = 0; - int i; - int first, total_count; - struct smb_dirent *current_entry; - word bcc; - word count; - char status[SMB_STATUS_SIZE]; - int entries_asked = (server->max_xmit - 100) / SMB_DIRINFO_SIZE; - int dirlen = strlen (path); - char * mask; + char *p; + char *buf; + int error; + int result = 0; + int i; + int first, total_count; + struct smb_dirent *current_entry; + word bcc; + word count; + char status[SMB_STATUS_SIZE]; + int entries_asked = (server->max_xmit - 100) / SMB_DIRINFO_SIZE; + int dirlen = strlen (path); + char * mask; - mask = malloc(dirlen + 4 + 1); - if (mask == NULL) - { - result = (-ENOMEM); - goto out; - } + mask = malloc(dirlen + 4 + 1); + if (mask == NULL) + { + result = (-ENOMEM); + goto out; + } - strcpy (mask, path); - strcat (mask, "\\*.*"); + strcpy (mask, path); + strcat (mask, "\\*.*"); - LOG (("SMB call readdir %ld @ %ld\n", cache_size, fpos)); - LOG ((" mask = %s\n", mask)); + LOG (("SMB call readdir %ld @ %ld\n", cache_size, fpos)); + LOG ((" mask = %s\n", mask)); - buf = server->packet; + buf = server->packet; retry: - first = 1; - total_count = 0; - current_entry = entry; + first = 1; + total_count = 0; + current_entry = entry; - while (1) - { - if (first == 1) - { - p = smb_setup_header (server, SMBsearch, 2, 5 + strlen (mask)); - WSET (buf, smb_vwv0, entries_asked); - WSET (buf, smb_vwv1, aDIR); - p = smb_encode_ascii (p, mask, strlen (mask)); - (*p++) = 5; - (void) smb_encode_word (p, 0); - } - else - { - p = smb_setup_header (server, SMBsearch, 2, 5 + SMB_STATUS_SIZE); - WSET (buf, smb_vwv0, entries_asked); - WSET (buf, smb_vwv1, aDIR); - p = smb_encode_ascii (p, "", 0); - (void) smb_encode_vblock (p, status, SMB_STATUS_SIZE, 0); - } + while (1) + { + if (first == 1) + { + p = smb_setup_header (server, SMBsearch, 2, 5 + strlen (mask)); + WSET (buf, smb_vwv0, entries_asked); + WSET (buf, smb_vwv1, aDIR); + p = smb_encode_ascii (p, mask, strlen (mask)); + (*p++) = 5; + (void) smb_encode_word (p, 0); + } + else + { + p = smb_setup_header (server, SMBsearch, 2, 5 + SMB_STATUS_SIZE); + WSET (buf, smb_vwv0, entries_asked); + WSET (buf, smb_vwv1, aDIR); + p = smb_encode_ascii (p, "", 0); + (void) smb_encode_vblock (p, status, SMB_STATUS_SIZE, 0); + } - if ((error = smb_request_ok (server, SMBsearch, 1, -1)) < 0) - { - if ((server->rcls == ERRDOS) && (server->err == ERRnofiles)) - { - result = total_count - fpos; - goto unlock_return; - } - else - { - if (smb_retry (server)) - goto retry; + if ((error = smb_request_ok (server, SMBsearch, 1, -1)) < 0) + { + if ((server->rcls == ERRDOS) && (server->err == ERRnofiles)) + { + result = total_count - fpos; + goto unlock_return; + } + else + { + if (smb_retry (server)) + goto retry; - result = error; + result = error; - goto unlock_return; - } - } + goto unlock_return; + } + } - p = SMB_VWV (server->packet); - p = smb_decode_word (p, &count); /* vwv[0] = count-returned */ - p = smb_decode_word (p, &bcc); + p = SMB_VWV (server->packet); + p = smb_decode_word (p, &count); /* vwv[0] = count-returned */ + p = smb_decode_word (p, &bcc); - first = 0; + first = 0; - if (count <= 0) - { - result = total_count - fpos; + if (count <= 0) + { + result = total_count - fpos; - goto unlock_return; - } + goto unlock_return; + } - if (bcc != count * SMB_DIRINFO_SIZE + 3) - { - result = -EIO; + if (bcc != count * SMB_DIRINFO_SIZE + 3) + { + result = -EIO; - goto unlock_return; - } + goto unlock_return; + } - p += 3; /* Skipping VBLOCK header (5, length lo, length hi). */ + p += 3; /* Skipping VBLOCK header (5, length lo, length hi). */ - /* Read the last entry into the status field. */ - memcpy (status, SMB_BUF (server->packet) + 3 + (count - 1) * SMB_DIRINFO_SIZE, SMB_STATUS_SIZE); + /* Read the last entry into the status field. */ + memcpy (status, SMB_BUF (server->packet) + 3 + (count - 1) * SMB_DIRINFO_SIZE, SMB_STATUS_SIZE); - /* Now we are ready to parse smb directory entries. */ + /* Now we are ready to parse smb directory entries. */ - for (i = 0; i < count; i++) - { - if (total_count < fpos) - { - p += SMB_DIRINFO_SIZE; + for (i = 0; i < count; i++) + { + if (total_count < fpos) + { + p += SMB_DIRINFO_SIZE; - LOG (("smb_proc_readdir: skipped entry; total_count = %ld, i = %ld, fpos = %ld\n", total_count, i, fpos)); - } - else if (total_count >= fpos + cache_size) - { - result = total_count - fpos; + LOG (("smb_proc_readdir: skipped entry; total_count = %ld, i = %ld, fpos = %ld\n", total_count, i, fpos)); + } + else if (total_count >= fpos + cache_size) + { + result = total_count - fpos; - goto unlock_return; - } - else - { - p = smb_decode_dirent (p, current_entry); + goto unlock_return; + } + else + { + p = smb_decode_dirent (p, current_entry); - current_entry += 1; - } + current_entry += 1; + } - total_count += 1; - } - } + total_count += 1; + } + } unlock_return: - if(mask != NULL) - free(mask); + if(mask != NULL) + free(mask); out: - return result; + return result; } /*****************************************************************************/ @@ -1287,36 +1284,36 @@ smb_proc_readdir_short (struct smb_server *server, char *path, int fpos, int cac static time_t interpret_long_date(char * p) { - QUAD adjust; - QUAD long_date; - ULONG underflow; - time_t result; + QUAD adjust; + QUAD long_date; + ULONG underflow; + time_t result; - /* Extract the 64 bit time value. */ - long_date.Low = DVAL(p,0); - long_date.High = DVAL(p,4); + /* Extract the 64 bit time value. */ + long_date.Low = DVAL(p,0); + long_date.High = DVAL(p,4); - /* Divide by 10,000,000 to convert the time from 100ns - units into seconds. */ - divide_64_by_32(&long_date,10000000,&long_date); + /* Divide by 10,000,000 to convert the time from 100ns + units into seconds. */ + divide_64_by_32(&long_date,10000000,&long_date); - /* Adjust by 369 years (11,644,473,600 seconds) to convert - from the epoch beginning on January 1st 1601 to the one - beginning on January 1st 1970 (the Unix epoch). */ - adjust.Low = 0xb6109100; - adjust.High = 0x00000002; + /* Adjust by 369 years (11,644,473,600 seconds) to convert + from the epoch beginning on January 1st 1601 to the one + beginning on January 1st 1970 (the Unix epoch). */ + adjust.Low = 0xb6109100; + adjust.High = 0x00000002; - underflow = subtract_64_from_64_to_64(&long_date,&adjust,&long_date); + underflow = subtract_64_from_64_to_64(&long_date,&adjust,&long_date); - /* If the result did not produce an underflow or overflow, - return the number of seconds encoded in the least - significant word of the result. */ - if(underflow == 0 && long_date.High == 0) - result = long_date.Low; - else - result = 0; + /* If the result did not produce an underflow or overflow, + return the number of seconds encoded in the least + significant word of the result. */ + if(underflow == 0 && long_date.High == 0) + result = long_date.Low; + else + result = 0; - return(result); + return(result); } /*****************************************************************************/ @@ -1324,678 +1321,678 @@ interpret_long_date(char * p) static void smb_get_dirent_name(char *p,int level,char ** name_ptr,int * len_ptr) { - switch (level) - { - case 1: /* OS/2 understands this */ - (*name_ptr) = p + 27; - (*len_ptr) = strlen(p + 27); - break; + switch (level) + { + case 1: /* OS/2 understands this */ + (*name_ptr) = p + 27; + (*len_ptr) = strlen(p + 27); + break; - case 2: /* this is what OS/2 uses */ - (*name_ptr) = p + 31; - (*len_ptr) = strlen(p + 31); - break; + case 2: /* this is what OS/2 uses */ + (*name_ptr) = p + 31; + (*len_ptr) = strlen(p + 31); + break; - case 3: /* untested */ - (*name_ptr) = p + 33; - (*len_ptr) = strlen(p + 33); - break; + case 3: /* untested */ + (*name_ptr) = p + 33; + (*len_ptr) = strlen(p + 33); + break; - case 4: /* untested */ - (*name_ptr) = p + 37; - (*len_ptr) = strlen(p + 37); - break; + case 4: /* untested */ + (*name_ptr) = p + 37; + (*len_ptr) = strlen(p + 37); + break; - case 260: /* NT uses this, but also accepts 2 */ - (*name_ptr) = p + 94; - (*len_ptr) = min (DVAL (p+60, 0), SMB_MAXNAMELEN); - break; + case 260: /* NT uses this, but also accepts 2 */ + (*name_ptr) = p + 94; + (*len_ptr) = min (DVAL (p+60, 0), SMB_MAXNAMELEN); + break; - default: - (*name_ptr) = NULL; - (*len_ptr) = 0; - break; - } + default: + (*name_ptr) = NULL; + (*len_ptr) = 0; + break; + } } /* interpret a long filename structure - this is mostly guesses at the - moment. The length of the structure is returned. The structure of + moment. The length of the structure is returned. The structure of a long filename depends on the info level. 260 is used by NT and 2 is used by OS/2. */ static char * smb_decode_long_dirent (char *p, struct smb_dirent *finfo, int level) { - char *result; + char *result; - switch (level) - { - case 1: /* OS/2 understands this */ + switch (level) + { + case 1: /* OS/2 understands this */ - #if DEBUG - { - char buffer[255]; + #if DEBUG + { + char buffer[255]; - memcpy(buffer,p + 27,sizeof(buffer)-1); - buffer[sizeof(buffer)-1] = '\0'; + memcpy(buffer,p + 27,sizeof(buffer)-1); + buffer[sizeof(buffer)-1] = '\0'; - LOG(("type=%ld, name='%s'\n",level,buffer)); - } - #endif /* DEBUG */ + LOG(("type=%ld, name='%s'\n",level,buffer)); + } + #endif /* DEBUG */ - if (finfo != NULL) - { - strlcpy (finfo->complete_path, p + 27, finfo->complete_path_size); - finfo->len = strlen (finfo->complete_path); - finfo->size = DVAL (p, 16); - finfo->attr = BVAL (p, 24); - finfo->ctime = date_dos2unix (WVAL (p, 6), WVAL (p, 4)); - finfo->atime = date_dos2unix (WVAL (p, 10), WVAL (p, 8)); - finfo->mtime = date_dos2unix (WVAL (p, 14), WVAL (p, 12)); - finfo->wtime = finfo->mtime; + if (finfo != NULL) + { + strlcpy (finfo->complete_path, p + 27, finfo->complete_path_size); + finfo->len = strlen (finfo->complete_path); + finfo->size = DVAL (p, 16); + finfo->attr = BVAL (p, 24); + finfo->ctime = date_dos2unix (WVAL (p, 6), WVAL (p, 4)); + finfo->atime = date_dos2unix (WVAL (p, 10), WVAL (p, 8)); + finfo->mtime = date_dos2unix (WVAL (p, 14), WVAL (p, 12)); + finfo->wtime = finfo->mtime; - #if DEBUG - { - struct tm tm; + #if DEBUG + { + struct tm tm; - GMTime(finfo->ctime,&tm); - LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(finfo->ctime,&tm); + LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(finfo->atime,&tm); - LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(finfo->atime,&tm); + LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(finfo->mtime,&tm); - LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(finfo->mtime,&tm); + LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(finfo->wtime,&tm); - LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - } - #endif /* DEBUG */ - } + GMTime(finfo->wtime,&tm); + LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + } + #endif /* DEBUG */ + } - result = p + 28 + BVAL (p, 26); + result = p + 28 + BVAL (p, 26); - break; + break; - case 2: /* this is what OS/2 uses */ + case 2: /* this is what OS/2 uses */ - #if DEBUG - { - char buffer[255]; + #if DEBUG + { + char buffer[255]; - memcpy(buffer,p + 31,sizeof(buffer)-1); - buffer[sizeof(buffer)-1] = '\0'; + memcpy(buffer,p + 31,sizeof(buffer)-1); + buffer[sizeof(buffer)-1] = '\0'; - LOG(("type=%ld, name='%s'\n",level,buffer)); - } - #endif /* DEBUG */ + LOG(("type=%ld, name='%s'\n",level,buffer)); + } + #endif /* DEBUG */ - if (finfo != NULL) - { - strlcpy (finfo->complete_path, p + 31, finfo->complete_path_size); - finfo->len = strlen (finfo->complete_path); - finfo->size = DVAL (p, 16); - finfo->attr = BVAL (p, 24); - finfo->ctime = date_dos2unix (WVAL (p, 6), WVAL (p, 4)); - finfo->atime = date_dos2unix (WVAL (p, 10), WVAL (p, 8)); - finfo->mtime = date_dos2unix (WVAL (p, 14), WVAL (p, 12)); - finfo->wtime = finfo->mtime; + if (finfo != NULL) + { + strlcpy (finfo->complete_path, p + 31, finfo->complete_path_size); + finfo->len = strlen (finfo->complete_path); + finfo->size = DVAL (p, 16); + finfo->attr = BVAL (p, 24); + finfo->ctime = date_dos2unix (WVAL (p, 6), WVAL (p, 4)); + finfo->atime = date_dos2unix (WVAL (p, 10), WVAL (p, 8)); + finfo->mtime = date_dos2unix (WVAL (p, 14), WVAL (p, 12)); + finfo->wtime = finfo->mtime; - #if DEBUG - { - struct tm tm; + #if DEBUG + { + struct tm tm; - GMTime(finfo->ctime,&tm); - LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(finfo->ctime,&tm); + LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(finfo->atime,&tm); - LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(finfo->atime,&tm); + LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(finfo->mtime,&tm); - LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(finfo->mtime,&tm); + LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(finfo->wtime,&tm); - LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - } - #endif /* DEBUG */ - } + GMTime(finfo->wtime,&tm); + LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + } + #endif /* DEBUG */ + } - result = p + 32 + BVAL (p, 30); + result = p + 32 + BVAL (p, 30); - break; + break; - case 260: /* NT uses this, but also accepts 2 */ + case 260: /* NT uses this, but also accepts 2 */ - #if DEBUG - { - char buffer[255]; - int len; + #if DEBUG + { + char buffer[255]; + int len; - len = min (DVAL (p+60, 0), sizeof(buffer)-1); + len = min (DVAL (p+60, 0), sizeof(buffer)-1); - memcpy(buffer,p+94,len); - buffer[len] = '\0'; + memcpy(buffer,p+94,len); + buffer[len] = '\0'; - LOG(("type=%ld, name='%s'\n",level,buffer)); - } - #endif /* DEBUG */ + LOG(("type=%ld, name='%s'\n",level,buffer)); + } + #endif /* DEBUG */ - result = p + WVAL (p, 0); + result = p + WVAL (p, 0); - if (finfo != NULL) - { - int namelen; - time_t swap; + if (finfo != NULL) + { + int namelen; + time_t swap; - p += 4; /* next entry offset */ - p += 4; /* fileindex */ - finfo->ctime = interpret_long_date(p); - p += 8; - finfo->atime = interpret_long_date(p); - p += 8; - finfo->wtime = interpret_long_date(p); - p += 8; - finfo->mtime = interpret_long_date(p); - p += 8; - finfo->size = DVAL (p, 0); - p += 8; - p += 8; /* alloc size */ - finfo->attr = BVAL (p, 0); - p += 4; - namelen = min (DVAL (p, 0), SMB_MAXNAMELEN); - p += 4; - p += 4; /* EA size */ - p += 2; /* short name len? */ - p += 24; /* short name? */ + p += 4; /* next entry offset */ + p += 4; /* fileindex */ + finfo->ctime = interpret_long_date(p); + p += 8; + finfo->atime = interpret_long_date(p); + p += 8; + finfo->wtime = interpret_long_date(p); + p += 8; + finfo->mtime = interpret_long_date(p); + p += 8; + finfo->size = DVAL (p, 0); + p += 8; + p += 8; /* alloc size */ + finfo->attr = BVAL (p, 0); + p += 4; + namelen = min (DVAL (p, 0), SMB_MAXNAMELEN); + p += 4; + p += 4; /* EA size */ + p += 2; /* short name len? */ + p += 24; /* short name? */ - if(namelen > (int)finfo->complete_path_size-1) - namelen = finfo->complete_path_size-1; + if(namelen > (int)finfo->complete_path_size-1) + namelen = finfo->complete_path_size-1; - /* If the modification time is not set, try to - substitute the write time for it. */ - if(finfo->mtime == 0) - finfo->mtime = finfo->wtime; + /* If the modification time is not set, try to + substitute the write time for it. */ + if(finfo->mtime == 0) + finfo->mtime = finfo->wtime; - /* Swap last modification time and last write time. */ - swap = finfo->mtime; - finfo->mtime = finfo->wtime; - finfo->wtime = swap; + /* Swap last modification time and last write time. */ + swap = finfo->mtime; + finfo->mtime = finfo->wtime; + finfo->wtime = swap; - memcpy (finfo->complete_path, p, namelen); - finfo->complete_path[namelen] = '\0'; - finfo->len = namelen; + memcpy (finfo->complete_path, p, namelen); + finfo->complete_path[namelen] = '\0'; + finfo->len = namelen; - #if DEBUG - { - struct tm tm; + #if DEBUG + { + struct tm tm; - GMTime(finfo->ctime,&tm); - LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(finfo->ctime,&tm); + LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(finfo->atime,&tm); - LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(finfo->atime,&tm); + LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(finfo->wtime,&tm); - LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(finfo->wtime,&tm); + LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(finfo->mtime,&tm); - LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - } - #endif /* DEBUG */ - } + GMTime(finfo->mtime,&tm); + LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + } + #endif /* DEBUG */ + } - break; + break; - default: + default: - if (finfo != NULL) - { - /* I have to set times to 0 here, because I do not - have specs about this for all info levels. */ - finfo->ctime = finfo->mtime = finfo->wtime = finfo->atime = 0; - } + if (finfo != NULL) + { + /* I have to set times to 0 here, because I do not + have specs about this for all info levels. */ + finfo->ctime = finfo->mtime = finfo->wtime = finfo->atime = 0; + } - LOG (("Unknown long filename format %ld\n", level)); + LOG (("Unknown long filename format %ld\n", level)); - result = p + WVAL (p, 0); + result = p + WVAL (p, 0); - break; - } + break; + } - return result; + return result; } static int smb_proc_readdir_long (struct smb_server *server, char *path, int fpos, int cache_size, struct smb_dirent *entry) { - int max_matches = 512; /* this should actually be based on the max_xmit value */ + int max_matches = 512; /* this should actually be based on the max_xmit value */ - /* NT uses 260, OS/2 uses 2. Both accept 1. */ - int info_level = server->protocol < PROTOCOL_NT1 ? 1 : 260; + /* NT uses 260, OS/2 uses 2. Both accept 1. */ + int info_level = server->protocol < PROTOCOL_NT1 ? 1 : 260; - char *p; - int i; - int first; - int total_count = 0; - struct smb_dirent *current_entry; + char *p; + int i; + int first; + int total_count = 0; + struct smb_dirent *current_entry; - char *resp_data; - char *resp_param; - int resp_data_len = 0; - int resp_param_len = 0; + char *resp_data; + char *resp_param; + int resp_data_len = 0; + int resp_param_len = 0; - int attribute = aSYSTEM | aHIDDEN | aDIR; - int result; - int error = 0; + int attribute = aSYSTEM | aHIDDEN | aDIR; + int result; + int error = 0; - int ff_searchcount; - int ff_eos = 0; - int ff_dir_handle = 0; - int ff_resume_key = 0; - int loop_count = 0; + int ff_searchcount; + int ff_eos = 0; + int ff_dir_handle = 0; + int ff_resume_key = 0; + int loop_count = 0; - unsigned char *outbuf = server->packet; + unsigned char *outbuf = server->packet; - int dirlen = strlen (path) + 2 + 1; - char *mask; - int masklen; + int dirlen = strlen (path) + 2 + 1; + char *mask; + int masklen; - ENTER(); + ENTER(); - /* ZZZ experimental 'max_matches' adjustment */ - /* - if(info_level == 260) - max_matches = server->max_xmit / 360; - else - max_matches = server->max_xmit / 40; - */ + /* ZZZ experimental 'max_matches' adjustment */ + /* + if(info_level == 260) + max_matches = server->max_xmit / 360; + else + max_matches = server->max_xmit / 40; + */ - SHOWVALUE(server->max_xmit); - SHOWVALUE(max_matches); + SHOWVALUE(server->max_xmit); + SHOWVALUE(max_matches); - mask = malloc (dirlen); - if (mask == NULL) - { - LOG (("Memory allocation failed\n")); - error = (-ENOMEM); - SHOWVALUE(error); - goto out; - } + mask = malloc (dirlen); + if (mask == NULL) + { + LOG (("Memory allocation failed\n")); + error = (-ENOMEM); + SHOWVALUE(error); + goto out; + } - strcpy (mask, path); - strcat (mask, "\\*"); - masklen = strlen (mask); + strcpy (mask, path); + strcat (mask, "\\*"); + masklen = strlen (mask); - LOG (("SMB call lreaddir %ld @ %ld\n", cache_size, fpos)); - LOG ((" mask = %s\n", mask)); + LOG (("SMB call lreaddir %ld @ %ld\n", cache_size, fpos)); + LOG ((" mask = %s\n", mask)); - resp_param = NULL; - resp_data = NULL; + resp_param = NULL; + resp_data = NULL; retry: - first = 1; - total_count = 0; - current_entry = entry; + first = 1; + total_count = 0; + current_entry = entry; - while (ff_eos == 0) - { - loop_count++; - if (loop_count > 200) - { - LOG (("smb_proc_readdir_long: Looping in FIND_NEXT???\n")); - error = -EIO; - SHOWVALUE(error); - break; - } + while (ff_eos == 0) + { + loop_count++; + if (loop_count > 200) + { + LOG (("smb_proc_readdir_long: Looping in FIND_NEXT???\n")); + error = -EIO; + SHOWVALUE(error); + break; + } - memset (outbuf, 0, 39); + memset (outbuf, 0, 39); - smb_setup_header (server, SMBtrans2, 15, 5 + 12 + masklen + 1); + smb_setup_header (server, SMBtrans2, 15, 5 + 12 + masklen + 1); - WSET (outbuf, smb_tpscnt, 12 + masklen + 1); - WSET (outbuf, smb_tdscnt, 0); - WSET (outbuf, smb_mprcnt, 10); - WSET (outbuf, smb_mdrcnt, server->max_xmit); - WSET (outbuf, smb_msrcnt, 0); - WSET (outbuf, smb_flags, 0); - DSET (outbuf, smb_timeout, 0); - WSET (outbuf, smb_pscnt, WVAL (outbuf, smb_tpscnt)); - WSET (outbuf, smb_psoff, ((SMB_BUF (outbuf) + 3) - outbuf) - 4); - WSET (outbuf, smb_dscnt, 0); - WSET (outbuf, smb_dsoff, 0); - WSET (outbuf, smb_suwcnt, 1); - WSET (outbuf, smb_setup0, first == 1 ? TRANSACT2_FINDFIRST : TRANSACT2_FINDNEXT); + WSET (outbuf, smb_tpscnt, 12 + masklen + 1); + WSET (outbuf, smb_tdscnt, 0); + WSET (outbuf, smb_mprcnt, 10); + WSET (outbuf, smb_mdrcnt, server->max_xmit); + WSET (outbuf, smb_msrcnt, 0); + WSET (outbuf, smb_flags, 0); + DSET (outbuf, smb_timeout, 0); + WSET (outbuf, smb_pscnt, WVAL (outbuf, smb_tpscnt)); + WSET (outbuf, smb_psoff, ((SMB_BUF (outbuf) + 3) - outbuf) - 4); + WSET (outbuf, smb_dscnt, 0); + WSET (outbuf, smb_dsoff, 0); + WSET (outbuf, smb_suwcnt, 1); + WSET (outbuf, smb_setup0, first == 1 ? TRANSACT2_FINDFIRST : TRANSACT2_FINDNEXT); - p = SMB_BUF (outbuf); - (*p++) = 0; /* put in a null smb_name */ - (*p++) = 'D'; - (*p++) = ' '; /* this was added because OS/2 does it */ + p = SMB_BUF (outbuf); + (*p++) = 0; /* put in a null smb_name */ + (*p++) = 'D'; + (*p++) = ' '; /* this was added because OS/2 does it */ - if (first != 0) - { - LOG (("first match\n")); - WSET (p, 0, attribute); /* attribute */ - WSET (p, 2, max_matches); /* max count */ - WSET (p, 4, 8 + 4 + 2); /* resume required + close on end + continue */ - WSET (p, 6, info_level); - DSET (p, 8, 0); - } - else - { - LOG (("next match; ff_dir_handle=0x%lx ff_resume_key=%ld mask='%s'\n", ff_dir_handle, ff_resume_key, mask)); - WSET (p, 0, ff_dir_handle); - WSET (p, 2, max_matches); /* max count */ - WSET (p, 4, info_level); - DSET (p, 6, ff_resume_key); - WSET (p, 10, 8 + 4 + 2); /* resume required + close on end + continue */ - } + if (first != 0) + { + LOG (("first match\n")); + WSET (p, 0, attribute); /* attribute */ + WSET (p, 2, max_matches); /* max count */ + WSET (p, 4, 8 + 4 + 2); /* resume required + close on end + continue */ + WSET (p, 6, info_level); + DSET (p, 8, 0); + } + else + { + LOG (("next match; ff_dir_handle=0x%lx ff_resume_key=%ld mask='%s'\n", ff_dir_handle, ff_resume_key, mask)); + WSET (p, 0, ff_dir_handle); + WSET (p, 2, max_matches); /* max count */ + WSET (p, 4, info_level); + DSET (p, 6, ff_resume_key); + WSET (p, 10, 8 + 4 + 2); /* resume required + close on end + continue */ + } - p += 12; + p += 12; - if(masklen > 0) - memcpy (p, mask, masklen); + if(masklen > 0) + memcpy (p, mask, masklen); - p += masklen; - (*p++) = 0; - (*p) = 0; + p += masklen; + (*p++) = 0; + (*p) = 0; - result = smb_trans2_request (server, &resp_data_len, &resp_param_len, &resp_data, &resp_param); + result = smb_trans2_request (server, &resp_data_len, &resp_param_len, &resp_data, &resp_param); - LOG (("smb_proc_readdir_long: smb_trans2_request returns %ld\n", result)); + LOG (("smb_proc_readdir_long: smb_trans2_request returns %ld\n", result)); - if (result < 0) - { - if (smb_retry (server)) - goto retry; + if (result < 0) + { + if (smb_retry (server)) + goto retry; - LOG (("smb_proc_readdir_long: got error from trans2_request\n")); - error = result; - SHOWVALUE(error); - break; - } + LOG (("smb_proc_readdir_long: got error from trans2_request\n")); + error = result; + SHOWVALUE(error); + break; + } - /* Apparently, there is a bug in Windows 95 and friends which - causes the directory read attempt to fail if you're asking - for too much data too fast... */ - if(server->rcls == ERRSRV && server->err == ERRerror) - { - SHOWMSG("ouch; delaying and retrying"); + /* Apparently, there is a bug in Windows 95 and friends which + causes the directory read attempt to fail if you're asking + for too much data too fast... */ + if(server->rcls == ERRSRV && server->err == ERRerror) + { + SHOWMSG("ouch; delaying and retrying"); - Delay(TICKS_PER_SECOND / 5); + Delay(TICKS_PER_SECOND / 5); - continue; - } + continue; + } - if (server->rcls != 0) - { - LOG (("server->rcls = %ld err = %ld\n",server->rcls, server->err)); - error = smb_errno (server->rcls, server->err); - SHOWVALUE(error); - break; - } + if (server->rcls != 0) + { + LOG (("server->rcls = %ld err = %ld\n",server->rcls, server->err)); + error = smb_errno (server->rcls, server->err); + SHOWVALUE(error); + break; + } - /* ZZZ bail out if this is empty. */ - if (resp_param == NULL) - break; + /* ZZZ bail out if this is empty. */ + if (resp_param == NULL) + break; - /* parse out some important return info */ - p = resp_param; - if (first != 0) - { - ff_dir_handle = WVAL (p, 0); - ff_searchcount = WVAL (p, 2); - ff_eos = WVAL (p, 4); - } - else - { - ff_searchcount = WVAL (p, 0); - ff_eos = WVAL (p, 2); - } + /* parse out some important return info */ + p = resp_param; + if (first != 0) + { + ff_dir_handle = WVAL (p, 0); + ff_searchcount = WVAL (p, 2); + ff_eos = WVAL (p, 4); + } + else + { + ff_searchcount = WVAL (p, 0); + ff_eos = WVAL (p, 2); + } - LOG (("received %ld entries (eos=%ld)\n",ff_searchcount, ff_eos)); - if (ff_searchcount == 0) - break; + LOG (("received %ld entries (eos=%ld)\n",ff_searchcount, ff_eos)); + if (ff_searchcount == 0) + break; - /* ZZZ bail out if this is empty. */ - if (resp_data == NULL) - break; + /* ZZZ bail out if this is empty. */ + if (resp_data == NULL) + break; - /* point to the data bytes */ - p = resp_data; + /* point to the data bytes */ + p = resp_data; - /* Now we are ready to parse smb directory entries. */ - for (i = 0; i < ff_searchcount; i++) - { - if(i == ff_searchcount - 1) - { - char * last_name; - int len; + /* Now we are ready to parse smb directory entries. */ + for (i = 0; i < ff_searchcount; i++) + { + if(i == ff_searchcount - 1) + { + char * last_name; + int len; - ff_resume_key = DVAL(p, 0); + ff_resume_key = DVAL(p, 0); - smb_get_dirent_name(p,info_level,&last_name,&len); - if(len > 0) - { - #if DEBUG - { - char buffer[SMB_MAXNAMELEN+1]; + smb_get_dirent_name(p,info_level,&last_name,&len); + if(len > 0) + { + #if DEBUG + { + char buffer[SMB_MAXNAMELEN+1]; - memcpy(buffer,last_name,len); - buffer[len] = '\0'; + memcpy(buffer,last_name,len); + buffer[len] = '\0'; - LOG(("last name = '%s'\n",buffer)); - } - #endif /* DEBUG */ + LOG(("last name = '%s'\n",buffer)); + } + #endif /* DEBUG */ - if(len + 1 > dirlen) - { - D(("increasing mask; old value = %ld new value = %ld",dirlen,len+1)); + if(len + 1 > dirlen) + { + D(("increasing mask; old value = %ld new value = %ld",dirlen,len+1)); - if(mask != NULL) - free (mask); + if(mask != NULL) + free (mask); - dirlen = len + 1; - SHOWVALUE(dirlen); + dirlen = len + 1; + SHOWVALUE(dirlen); - mask = malloc (dirlen); - if (mask == NULL) - { - LOG (("smb_proc_readdir_long: Memory allocation failed\n")); + mask = malloc (dirlen); + if (mask == NULL) + { + LOG (("smb_proc_readdir_long: Memory allocation failed\n")); - error = -ENOMEM; + error = -ENOMEM; - SHOWVALUE(error); + SHOWVALUE(error); - goto fail; - } - } + goto fail; + } + } - memcpy (mask, last_name, len); - mask[len] = '\0'; - masklen = len; - } - else - { - masklen = 0; - } - } + memcpy (mask, last_name, len); + mask[len] = '\0'; + masklen = len; + } + else + { + masklen = 0; + } + } - if (total_count < fpos) - { - p = smb_decode_long_dirent (p, NULL, info_level); + if (total_count < fpos) + { + p = smb_decode_long_dirent (p, NULL, info_level); - LOG (("smb_proc_readdir: skipped entry; total_count = %ld, i = %ld, fpos = %ld\n",total_count, i, fpos)); - } - else if (total_count >= fpos + cache_size) - { - p = smb_decode_long_dirent (p, NULL, info_level); + LOG (("smb_proc_readdir: skipped entry; total_count = %ld, i = %ld, fpos = %ld\n",total_count, i, fpos)); + } + else if (total_count >= fpos + cache_size) + { + p = smb_decode_long_dirent (p, NULL, info_level); - LOG (("smb_proc_readdir: skipped entry; total_count = %ld, i = %ld, fpos = %ld\n",total_count, i, fpos)); + LOG (("smb_proc_readdir: skipped entry; total_count = %ld, i = %ld, fpos = %ld\n",total_count, i, fpos)); - continue; - } - else - { - p = smb_decode_long_dirent (p, current_entry, info_level); + continue; + } + else + { + p = smb_decode_long_dirent (p, current_entry, info_level); - current_entry += 1; - } + current_entry += 1; + } - total_count += 1; - } + total_count += 1; + } - SHOWVALUE(ff_resume_key); + SHOWVALUE(ff_resume_key); - if (resp_data != NULL) - { - free (resp_data); - resp_data = NULL; - } + if (resp_data != NULL) + { + free (resp_data); + resp_data = NULL; + } - if (resp_param != NULL) - { - free (resp_param); - resp_param = NULL; - } + if (resp_param != NULL) + { + free (resp_param); + resp_param = NULL; + } - first = 0; + first = 0; - if (ff_searchcount > 0) - loop_count = 0; - } + if (ff_searchcount > 0) + loop_count = 0; + } fail: - /* finished: not needed any more */ - if (mask != NULL) - free (mask); + /* finished: not needed any more */ + if (mask != NULL) + free (mask); - if (resp_data != NULL) - free (resp_data); + if (resp_data != NULL) + free (resp_data); - if (resp_param != NULL) - free (resp_param); + if (resp_param != NULL) + free (resp_param); out: - if(error < 0) - { - RETURN(error); - return(error); - } - else - { - RETURN (total_count - fpos); - return (total_count - fpos); - } + if(error < 0) + { + RETURN(error); + return(error); + } + else + { + RETURN (total_count - fpos); + return (total_count - fpos); + } } int smb_proc_readdir (struct smb_server *server, char *path, int fpos, int cache_size, struct smb_dirent *entry) { - int result; + int result; - if (server->protocol >= PROTOCOL_LANMAN2) - result = smb_proc_readdir_long (server, path, fpos, cache_size, entry); - else - result = smb_proc_readdir_short (server, path, fpos, cache_size, entry); + if (server->protocol >= PROTOCOL_LANMAN2) + result = smb_proc_readdir_long (server, path, fpos, cache_size, entry); + else + result = smb_proc_readdir_short (server, path, fpos, cache_size, entry); - return result; + return result; } int smb_proc_getattr_core (struct smb_server *server, const char *path, int len, struct smb_dirent *entry) { - int result; - char *p; - char *buf = server->packet; + int result; + char *p; + char *buf = server->packet; - LOG (("smb_proc_getattr: %s\n", path)); + LOG (("smb_proc_getattr: %s\n", path)); retry: - p = smb_setup_header (server, SMBgetatr, 0, 2 + len); - smb_encode_ascii (p, path, len); + p = smb_setup_header (server, SMBgetatr, 0, 2 + len); + smb_encode_ascii (p, path, len); - if ((result = smb_request_ok (server, SMBgetatr, 10, 0)) < 0) - { - if (smb_retry (server)) - goto retry; + if ((result = smb_request_ok (server, SMBgetatr, 10, 0)) < 0) + { + if (smb_retry (server)) + goto retry; - goto out; - } + goto out; + } - entry->attr = WVAL (buf, smb_vwv0); + entry->attr = WVAL (buf, smb_vwv0); - /* The server only tells us 1 time */ - entry->ctime = entry->atime = entry->mtime = entry->wtime = local2utc (DVAL (buf, smb_vwv1)); + /* The server only tells us 1 time */ + entry->ctime = entry->atime = entry->mtime = entry->wtime = local2utc (DVAL (buf, smb_vwv1)); - entry->size = DVAL (buf, smb_vwv3); + entry->size = DVAL (buf, smb_vwv3); - #if DEBUG - { - struct tm tm; + #if DEBUG + { + struct tm tm; - GMTime(entry->ctime,&tm); - LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(entry->ctime,&tm); + LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(entry->atime,&tm); - LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(entry->atime,&tm); + LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(entry->mtime,&tm); - LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(entry->mtime,&tm); + LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(entry->wtime,&tm); - LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - } - #endif /* DEBUG */ + GMTime(entry->wtime,&tm); + LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + } + #endif /* DEBUG */ out: - return result; + return result; } /* smb_proc_getattrE: entry->fid must be valid */ int smb_proc_getattrE (struct smb_server *server, struct smb_dirent *entry) { - char *buf = server->packet; - int result; + char *buf = server->packet; + int result; - smb_setup_header_exclusive (server, SMBgetattrE, 1, 0); - WSET (buf, smb_vwv0, entry->fileid); + smb_setup_header_exclusive (server, SMBgetattrE, 1, 0); + WSET (buf, smb_vwv0, entry->fileid); - if ((result = smb_request_ok (server, SMBgetattrE, 11, 0)) < 0) - goto out; + if ((result = smb_request_ok (server, SMBgetattrE, 11, 0)) < 0) + goto out; - entry->ctime = date_dos2unix (WVAL (buf, smb_vwv1), WVAL (buf, smb_vwv0)); - entry->atime = date_dos2unix (WVAL (buf, smb_vwv3), WVAL (buf, smb_vwv2)); - entry->mtime = date_dos2unix (WVAL (buf, smb_vwv5), WVAL (buf, smb_vwv4)); - entry->wtime = entry->mtime; - entry->size = DVAL (buf, smb_vwv6); - entry->attr = WVAL (buf, smb_vwv10); + entry->ctime = date_dos2unix (WVAL (buf, smb_vwv1), WVAL (buf, smb_vwv0)); + entry->atime = date_dos2unix (WVAL (buf, smb_vwv3), WVAL (buf, smb_vwv2)); + entry->mtime = date_dos2unix (WVAL (buf, smb_vwv5), WVAL (buf, smb_vwv4)); + entry->wtime = entry->mtime; + entry->size = DVAL (buf, smb_vwv6); + entry->attr = WVAL (buf, smb_vwv10); - #if DEBUG - { - struct tm tm; + #if DEBUG + { + struct tm tm; - GMTime(entry->ctime,&tm); - LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(entry->ctime,&tm); + LOG(("ctime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(entry->atime,&tm); - LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(entry->atime,&tm); + LOG(("atime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(entry->mtime,&tm); - LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + GMTime(entry->mtime,&tm); + LOG(("mtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - GMTime(entry->wtime,&tm); - LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); - } - #endif /* DEBUG */ + GMTime(entry->wtime,&tm); + LOG(("wtime = %ld-%02ld-%02ld %ld:%02ld:%02ld\n",tm.tm_year + 1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec)); + } + #endif /* DEBUG */ out: - return result; + return result; } /* In core protocol, there is only 1 time to be set, we use @@ -2003,29 +2000,29 @@ smb_proc_getattrE (struct smb_server *server, struct smb_dirent *entry) int smb_proc_setattr_core (struct smb_server *server, const char *path, int len, struct smb_dirent *new_finfo) { - char *p; - char *buf = server->packet; - int result; - int local_time; + char *p; + char *buf = server->packet; + int result; + int local_time; retry: - LOG (("smb_proc_setattr_core\n")); + LOG (("smb_proc_setattr_core\n")); - p = smb_setup_header (server, SMBsetatr, 8, 4 + len); - WSET (buf, smb_vwv0, new_finfo->attr); - local_time = utc2local (new_finfo->mtime); - DSET (buf, smb_vwv1, local_time); - p = smb_encode_ascii (p, path, len); - (void) smb_encode_ascii (p, "", 0); + p = smb_setup_header (server, SMBsetatr, 8, 4 + len); + WSET (buf, smb_vwv0, new_finfo->attr); + local_time = utc2local (new_finfo->mtime); + DSET (buf, smb_vwv1, local_time); + p = smb_encode_ascii (p, path, len); + (void) smb_encode_ascii (p, "", 0); - if ((result = smb_request_ok (server, SMBsetatr, 0, 0)) < 0) - { - if (smb_retry (server)) - goto retry; - } + if ((result = smb_request_ok (server, SMBsetatr, 0, 0)) < 0) + { + if (smb_retry (server)) + goto retry; + } - return result; + return result; } /* smb_proc_setattrE: we do not retry here, because we rely on fid, @@ -2033,60 +2030,60 @@ smb_proc_setattr_core (struct smb_server *server, const char *path, int len, str int smb_proc_setattrE (struct smb_server *server, word fid, struct smb_dirent *new_entry) { - char *buf = server->packet; - word date, time_value; - int result; + char *buf = server->packet; + word date, time_value; + int result; - LOG (("smb_proc_setattrE\n")); + LOG (("smb_proc_setattrE\n")); - smb_setup_header_exclusive (server, SMBsetattrE, 7, 0); + smb_setup_header_exclusive (server, SMBsetattrE, 7, 0); - WSET (buf, smb_vwv0, fid); + WSET (buf, smb_vwv0, fid); - date_unix2dos (new_entry->ctime, &time_value, &date); - WSET (buf, smb_vwv1, date); - WSET (buf, smb_vwv2, time_value); + date_unix2dos (new_entry->ctime, &time_value, &date); + WSET (buf, smb_vwv1, date); + WSET (buf, smb_vwv2, time_value); - date_unix2dos (new_entry->atime, &time_value, &date); - WSET (buf, smb_vwv3, date); - WSET (buf, smb_vwv4, time_value); + date_unix2dos (new_entry->atime, &time_value, &date); + WSET (buf, smb_vwv3, date); + WSET (buf, smb_vwv4, time_value); - date_unix2dos (new_entry->mtime, &time_value, &date); - WSET (buf, smb_vwv5, date); - WSET (buf, smb_vwv6, time_value); + date_unix2dos (new_entry->mtime, &time_value, &date); + WSET (buf, smb_vwv5, date); + WSET (buf, smb_vwv6, time_value); - result = smb_request_ok_unlock (server, SMBsetattrE, 0, 0); + result = smb_request_ok_unlock (server, SMBsetattrE, 0, 0); - return result; + return result; } int smb_proc_dskattr (struct smb_server *server, struct smb_dskattr *attr) { - int error; - char *p; + int error; + char *p; retry: - smb_setup_header (server, SMBdskattr, 0, 0); + smb_setup_header (server, SMBdskattr, 0, 0); - if ((error = smb_request_ok (server, SMBdskattr, 5, 0)) < 0) - { - if (smb_retry (server)) - goto retry; + if ((error = smb_request_ok (server, SMBdskattr, 5, 0)) < 0) + { + if (smb_retry (server)) + goto retry; - goto out; - } + goto out; + } - p = SMB_VWV (server->packet); - p = smb_decode_word (p, &attr->total); - p = smb_decode_word (p, &attr->allocblocks); - p = smb_decode_word (p, &attr->blocksize); - (void) smb_decode_word (p, &attr->free); + p = SMB_VWV (server->packet); + p = smb_decode_word (p, &attr->total); + p = smb_decode_word (p, &attr->allocblocks); + p = smb_decode_word (p, &attr->blocksize); + (void) smb_decode_word (p, &attr->free); out: - return error; + return error; } /***************************************************************************** @@ -2096,8 +2093,8 @@ smb_proc_dskattr (struct smb_server *server, struct smb_dskattr *attr) ****************************************************************************/ struct smb_prots { - enum smb_protocol prot; - const char *name; + enum smb_protocol prot; + const char *name; }; /* smb_proc_reconnect: We expect the server to be locked, so that you @@ -2107,423 +2104,423 @@ struct smb_prots static int smb_proc_reconnect (struct smb_server *server) { - static const struct smb_prots prots[] = - { - {PROTOCOL_CORE, "PC NETWORK PROGRAM 1.0"}, - {PROTOCOL_COREPLUS, "MICROSOFT NETWORKS 1.03"}, - {PROTOCOL_LANMAN1, "MICROSOFT NETWORKS 3.0"}, - {PROTOCOL_LANMAN1, "LANMAN1.0"}, - {PROTOCOL_LANMAN2, "LM1.2X002"}, - {PROTOCOL_NT1, "NT LM 0.12"}, - {PROTOCOL_NT1, "NT LANMAN 1.0"}, - - {-1, NULL} - }; - - char dev[] = "A:"; - int i, plength; - int max_xmit = 1024; /* Space needed for first request. */ - int given_max_xmit = server->mount_data.given_max_xmit; - int result; - word any_word; - byte *p; - unsigned char password[24]; - int password_len; - unsigned char nt_password[24]; - int nt_password_len; - unsigned char full_share[SMB_MAXNAMELEN+1]; - int full_share_len; - byte *packet; - word server_maxxmt; - - /* Reception buffer size (buffer is allocated below) is always as large as the - * maximum transmission buffer size, and could be larger if the transmission - * buffer size is smaller than 8000 bytes. - */ - if (server->max_recv <= 0) - server->max_recv = given_max_xmit < 8000 ? 8000 : given_max_xmit; - - if ((result = smb_connect (server)) < 0) /* this is really a plain connect() call */ - { - LOG (("smb_proc_reconnect: could not smb_connect\n")); - goto fail; - } - - /* Here we assume that the connection is valid */ - server->state = CONN_VALID; - - if (server->packet != NULL) - free (server->packet); - - server->packet = malloc (server->max_recv); - if (server->packet == NULL) - { - LOG (("smb_proc_connect: No memory! Bailing out.\n")); - result = -ENOMEM; - goto fail; - } - - packet = server->packet; - - server->max_xmit = max_xmit; - - /* Prepend a NetBIOS header? */ - if(!server->raw_smb) - { - /* Start with an RFC1002 session request packet. */ - p = packet + 4; - - p = smb_name_mangle (p, server->mount_data.server_name); - p = smb_name_mangle (p, server->mount_data.client_name); - - smb_encode_smb_length (packet, (byte *) p - (byte *) (packet)); - - packet[0] = 0x81; /* SESSION REQUEST */ - - if ((result = smb_request (server)) < 0) - { - LOG (("smb_proc_connect: Failed to send SESSION REQUEST.\n")); - goto fail; - } - - if (packet[0] != 0x82) - { - LOG (("smb_proc_connect: Did not receive positive response (err = %lx)\n",packet[0])); - - #if DEBUG - { - smb_dump_packet (packet); - } - #endif /* DEBUG */ - - result = -EIO; - goto fail; - } - - LOG (("smb_proc_connect: Passed SESSION REQUEST.\n")); - } - - /* Now we are ready to send a SMB Negotiate Protocol packet. */ - memset (packet, 0, SMB_HEADER_LEN); - - plength = 0; - for (i = 0; prots[i].name != NULL; i++) - plength += strlen (prots[i].name) + 2; - - smb_setup_header (server, SMBnegprot, 0, plength); - - p = SMB_BUF (packet); - - for (i = 0; prots[i].name != NULL; i++) - p = smb_encode_dialect (p, prots[i].name, strlen (prots[i].name)); - - LOG (("smb_proc_connect: Request SMBnegprot...\n")); - if ((result = smb_request_ok (server, SMBnegprot, 1, -1)) < 0) - { - LOG (("smb_proc_connect: Failure requesting SMBnegprot\n")); - goto fail; - } - - LOG (("Verified!\n")); - - p = SMB_VWV (packet); - p = smb_decode_word (p, &any_word); - i = any_word; - - server->protocol = prots[i].prot; + static const struct smb_prots prots[] = + { + {PROTOCOL_CORE, "PC NETWORK PROGRAM 1.0"}, + {PROTOCOL_COREPLUS, "MICROSOFT NETWORKS 1.03"}, + {PROTOCOL_LANMAN1, "MICROSOFT NETWORKS 3.0"}, + {PROTOCOL_LANMAN1, "LANMAN1.0"}, + {PROTOCOL_LANMAN2, "LM1.2X002"}, + {PROTOCOL_NT1, "NT LM 0.12"}, + {PROTOCOL_NT1, "NT LANMAN 1.0"}, + + {-1, NULL} + }; + + char dev[] = "A:"; + int i, plength; + int max_xmit = 1024; /* Space needed for first request. */ + int given_max_xmit = server->mount_data.given_max_xmit; + int result; + word any_word; + byte *p; + unsigned char password[24]; + int password_len; + unsigned char nt_password[24]; + int nt_password_len; + unsigned char full_share[SMB_MAXNAMELEN+1]; + int full_share_len; + byte *packet; + word server_maxxmt; + + /* Reception buffer size (buffer is allocated below) is always as large as the + * maximum transmission buffer size, and could be larger if the transmission + * buffer size is smaller than 8000 bytes. + */ + if (server->max_recv <= 0) + server->max_recv = given_max_xmit < 8000 ? 8000 : given_max_xmit; + + if ((result = smb_connect (server)) < 0) /* this is really a plain connect() call */ + { + LOG (("smb_proc_reconnect: could not smb_connect\n")); + goto fail; + } + + /* Here we assume that the connection is valid */ + server->state = CONN_VALID; + + if (server->packet != NULL) + free (server->packet); + + server->packet = malloc (server->max_recv); + if (server->packet == NULL) + { + LOG (("smb_proc_connect: No memory! Bailing out.\n")); + result = -ENOMEM; + goto fail; + } + + packet = server->packet; + + server->max_xmit = max_xmit; + + /* Prepend a NetBIOS header? */ + if(!server->raw_smb) + { + /* Start with an RFC1002 session request packet. */ + p = packet + 4; + + p = smb_name_mangle (p, server->mount_data.server_name); + p = smb_name_mangle (p, server->mount_data.client_name); + + smb_encode_smb_length (packet, (byte *) p - (byte *) (packet)); + + packet[0] = 0x81; /* SESSION REQUEST */ + + if ((result = smb_request (server)) < 0) + { + LOG (("smb_proc_connect: Failed to send SESSION REQUEST.\n")); + goto fail; + } + + if (packet[0] != 0x82) + { + LOG (("smb_proc_connect: Did not receive positive response (err = %lx)\n",packet[0])); + + #if DEBUG + { + smb_dump_packet (packet); + } + #endif /* DEBUG */ + + result = -EIO; + goto fail; + } + + LOG (("smb_proc_connect: Passed SESSION REQUEST.\n")); + } + + /* Now we are ready to send a SMB Negotiate Protocol packet. */ + memset (packet, 0, SMB_HEADER_LEN); + + plength = 0; + for (i = 0; prots[i].name != NULL; i++) + plength += strlen (prots[i].name) + 2; + + smb_setup_header (server, SMBnegprot, 0, plength); + + p = SMB_BUF (packet); + + for (i = 0; prots[i].name != NULL; i++) + p = smb_encode_dialect (p, prots[i].name, strlen (prots[i].name)); + + LOG (("smb_proc_connect: Request SMBnegprot...\n")); + if ((result = smb_request_ok (server, SMBnegprot, 1, -1)) < 0) + { + LOG (("smb_proc_connect: Failure requesting SMBnegprot\n")); + goto fail; + } + + LOG (("Verified!\n")); + + p = SMB_VWV (packet); + p = smb_decode_word (p, &any_word); + i = any_word; + + server->protocol = prots[i].prot; - LOG (("smb_proc_connect: Server wants %s protocol.\n",prots[i].name)); + LOG (("smb_proc_connect: Server wants %s protocol.\n",prots[i].name)); - if (server->protocol > PROTOCOL_LANMAN1) - { - int user_len = strlen (server->mount_data.username)+1; - dword server_sesskey; - - LOG (("smb_proc_connect: password = %s\n",server->mount_data.password)); - LOG (("smb_proc_connect: usernam = %s\n",server->mount_data.username)); - LOG (("smb_proc_connect: blkmode = %ld\n",WVAL (packet, smb_vwv5))); + if (server->protocol > PROTOCOL_LANMAN1) + { + int user_len = strlen (server->mount_data.username)+1; + dword server_sesskey; + + LOG (("smb_proc_connect: password = %s\n",server->mount_data.password)); + LOG (("smb_proc_connect: usernam = %s\n",server->mount_data.username)); + LOG (("smb_proc_connect: blkmode = %ld\n",WVAL (packet, smb_vwv5))); - if (server->protocol >= PROTOCOL_NT1) - { - server_maxxmt = DVAL (packet, smb_vwv3 + 1); - server->blkmode = DVAL (packet, smb_vwv9 + 1); - server_sesskey = DVAL (packet, smb_vwv7 + 1); + if (server->protocol >= PROTOCOL_NT1) + { + server_maxxmt = DVAL (packet, smb_vwv3 + 1); + server->blkmode = DVAL (packet, smb_vwv9 + 1); + server_sesskey = DVAL (packet, smb_vwv7 + 1); - server->security_mode = BVAL(packet, smb_vwv1); + server->security_mode = BVAL(packet, smb_vwv1); - memcpy(server->crypt_key,SMB_BUF(packet),8); - } - else - { - server_maxxmt = WVAL (packet, smb_vwv2); - server->blkmode = WVAL (packet, smb_vwv5); - server_sesskey = DVAL (packet, smb_vwv6); + memcpy(server->crypt_key,SMB_BUF(packet),8); + } + else + { + server_maxxmt = WVAL (packet, smb_vwv2); + server->blkmode = WVAL (packet, smb_vwv5); + server_sesskey = DVAL (packet, smb_vwv6); - server->security_mode = BVAL(packet, smb_vwv1); + server->security_mode = BVAL(packet, smb_vwv1); - memcpy(server->crypt_key,SMB_BUF(packet),8); - } + memcpy(server->crypt_key,SMB_BUF(packet),8); + } - SHOWVALUE(server->security_mode); + SHOWVALUE(server->security_mode); - if(server->security_mode & 2) - { - SHOWMSG("encrypted passwords required"); + if(server->security_mode & 2) + { + SHOWMSG("encrypted passwords required"); - memset(password,0,sizeof(password)); - strlcpy(password,server->mount_data.password,sizeof(password)); + memset(password,0,sizeof(password)); + strlcpy(password,server->mount_data.password,sizeof(password)); - smb_encrypt(password,server->crypt_key,password); - password_len = 24; + smb_encrypt(password,server->crypt_key,password); + password_len = 24; - PRINTHEADER(); - PRINTF(("password: ")); - for(i = 0 ; i < 24 ; i++) - PRINTF(("%02lx ",password[i])); - PRINTF(("\n")); - - memset(nt_password,0,sizeof(nt_password)); - strlcpy(nt_password,server->mount_data.password,sizeof(nt_password)); - - smb_nt_encrypt(nt_password,server->crypt_key,nt_password); - nt_password_len = 24; - - PRINTHEADER(); - PRINTF(("nt_password: ")); - for(i = 0 ; i < 24 ; i++) - PRINTF(("%02lx ",nt_password[i])); - PRINTF(("\n")); - - PRINTHEADER(); - PRINTF(("crypt_key: ")); - for(i = 0 ; i < 8 ; i++) - PRINTF(("%02lx ",server->crypt_key[i])); - PRINTF(("\n")); - } - else - { - SHOWMSG("plain text passwords sufficient"); - - password_len = strlen(server->mount_data.password)+1; - nt_password_len = 0; - } - - /* If in share level security then don't send a password now */ - if((server->security_mode & 1) == 0) - { - SHOWMSG("share level security; zapping passwords"); - strcpy(password,""); - password_len = 0; - - strcpy(nt_password,""); - nt_password_len = 0; - } - - SHOWVALUE(password_len); - SHOWVALUE(nt_password_len); - - LOG (("smb_proc_connect: workgroup = %s\n", server->mount_data.workgroup_name)); - if (server->protocol >= PROTOCOL_NT1) - { - char *OS_id = "AmigaOS"; - char *client_id = "smbfs"; - - SHOWMSG("server->protocol >= PROTOCOL_NT1"); - - smb_setup_header (server, SMBsesssetupX, 13, user_len + password_len + nt_password_len + strlen (server->mount_data.workgroup_name)+1 + strlen (OS_id)+1 + strlen (client_id)+1); - - WSET (packet, smb_vwv0, 0xff); - WSET (packet, smb_vwv2, given_max_xmit); - WSET (packet, smb_vwv3, 2); - WSET (packet, smb_vwv4, 0); /* server->pid */ - DSET (packet, smb_vwv5, server_sesskey); - WSET (packet, smb_vwv7, password_len); - WSET (packet, smb_vwv8, nt_password_len); - - p = SMB_BUF (packet); - - if(nt_password_len != 0) - { - SHOWMSG("adding encrypted passwords"); - - memcpy (p, password, password_len); - p += password_len; + PRINTHEADER(); + PRINTF(("password: ")); + for(i = 0 ; i < 24 ; i++) + PRINTF(("%02lx ",password[i])); + PRINTF(("\n")); + + memset(nt_password,0,sizeof(nt_password)); + strlcpy(nt_password,server->mount_data.password,sizeof(nt_password)); + + smb_nt_encrypt(nt_password,server->crypt_key,nt_password); + nt_password_len = 24; + + PRINTHEADER(); + PRINTF(("nt_password: ")); + for(i = 0 ; i < 24 ; i++) + PRINTF(("%02lx ",nt_password[i])); + PRINTF(("\n")); + + PRINTHEADER(); + PRINTF(("crypt_key: ")); + for(i = 0 ; i < 8 ; i++) + PRINTF(("%02lx ",server->crypt_key[i])); + PRINTF(("\n")); + } + else + { + SHOWMSG("plain text passwords sufficient"); + + password_len = strlen(server->mount_data.password)+1; + nt_password_len = 0; + } + + /* If in share level security then don't send a password now */ + if((server->security_mode & 1) == 0) + { + SHOWMSG("share level security; zapping passwords"); + strcpy(password,""); + password_len = 0; + + strcpy(nt_password,""); + nt_password_len = 0; + } + + SHOWVALUE(password_len); + SHOWVALUE(nt_password_len); + + LOG (("smb_proc_connect: workgroup = %s\n", server->mount_data.workgroup_name)); + if (server->protocol >= PROTOCOL_NT1) + { + char *OS_id = "AmigaOS"; + char *client_id = "smbfs"; + + SHOWMSG("server->protocol >= PROTOCOL_NT1"); + + smb_setup_header (server, SMBsesssetupX, 13, user_len + password_len + nt_password_len + strlen (server->mount_data.workgroup_name)+1 + strlen (OS_id)+1 + strlen (client_id)+1); + + WSET (packet, smb_vwv0, 0xff); + WSET (packet, smb_vwv2, given_max_xmit); + WSET (packet, smb_vwv3, 2); + WSET (packet, smb_vwv4, 0); /* server->pid */ + DSET (packet, smb_vwv5, server_sesskey); + WSET (packet, smb_vwv7, password_len); + WSET (packet, smb_vwv8, nt_password_len); + + p = SMB_BUF (packet); + + if(nt_password_len != 0) + { + SHOWMSG("adding encrypted passwords"); + + memcpy (p, password, password_len); + p += password_len; - memcpy (p, nt_password, nt_password_len); - p += nt_password_len; - } - else - { - SHOWMSG("adding plain text password"); + memcpy (p, nt_password, nt_password_len); + p += nt_password_len; + } + else + { + SHOWMSG("adding plain text password"); - memcpy (p, server->mount_data.password, password_len); - p += password_len; - } + memcpy (p, server->mount_data.password, password_len); + p += password_len; + } - memcpy (p, server->mount_data.username, user_len); - p += user_len; + memcpy (p, server->mount_data.username, user_len); + p += user_len; - strcpy (p, server->mount_data.workgroup_name); - p += strlen (p) + 1; + strcpy (p, server->mount_data.workgroup_name); + p += strlen (p) + 1; - strcpy (p, OS_id); - p += strlen (p) + 1; - - strcpy (p, client_id); - } - else - { - smb_setup_header (server, SMBsesssetupX, 10, user_len + password_len); - - WSET (packet, smb_vwv0, 0xff); - WSET (packet, smb_vwv1, 0); - WSET (packet, smb_vwv2, given_max_xmit); - WSET (packet, smb_vwv3, 2); - WSET (packet, smb_vwv4, 0); /* server->pid */ - DSET (packet, smb_vwv5, server_sesskey); - WSET (packet, smb_vwv7, password_len); - WSET (packet, smb_vwv8, 0); - WSET (packet, smb_vwv9, 0); - - p = SMB_BUF (packet); - memcpy (p, server->mount_data.password, password_len); - p += password_len; - memcpy (p, server->mount_data.username, user_len); - } - - if ((result = smb_request_ok (server, SMBsesssetupX, 3, 0)) < 0) - { - LOG (("smb_proc_connect: SMBsessetupX failed\n")); - goto fail; - } + strcpy (p, OS_id); + p += strlen (p) + 1; + + strcpy (p, client_id); + } + else + { + smb_setup_header (server, SMBsesssetupX, 10, user_len + password_len); + + WSET (packet, smb_vwv0, 0xff); + WSET (packet, smb_vwv1, 0); + WSET (packet, smb_vwv2, given_max_xmit); + WSET (packet, smb_vwv3, 2); + WSET (packet, smb_vwv4, 0); /* server->pid */ + DSET (packet, smb_vwv5, server_sesskey); + WSET (packet, smb_vwv7, password_len); + WSET (packet, smb_vwv8, 0); + WSET (packet, smb_vwv9, 0); + + p = SMB_BUF (packet); + memcpy (p, server->mount_data.password, password_len); + p += password_len; + memcpy (p, server->mount_data.username, user_len); + } + + if ((result = smb_request_ok (server, SMBsesssetupX, 3, 0)) < 0) + { + LOG (("smb_proc_connect: SMBsessetupX failed\n")); + goto fail; + } - smb_decode_word (packet + 32, &(server->server_uid)); - } - else - { - server_maxxmt = 0; - server->blkmode = 0; + smb_decode_word (packet + 32, &(server->server_uid)); + } + else + { + server_maxxmt = 0; + server->blkmode = 0; - password_len = strlen(server->mount_data.password)+1; + password_len = strlen(server->mount_data.password)+1; - nt_password_len = 0; - } + nt_password_len = 0; + } - if(nt_password_len > 0) - { - strlcpy(full_share,"//",sizeof(full_share)); - strlcat(full_share,server->mount_data.server_name,sizeof(full_share)); - strlcat(full_share,"/",sizeof(full_share)); - strlcat(full_share,server->mount_data.service,sizeof(full_share)); + if(nt_password_len > 0) + { + strlcpy(full_share,"//",sizeof(full_share)); + strlcat(full_share,server->mount_data.server_name,sizeof(full_share)); + strlcat(full_share,"/",sizeof(full_share)); + strlcat(full_share,server->mount_data.service,sizeof(full_share)); - full_share_len = strlen(full_share); + full_share_len = strlen(full_share); - for(i = 0 ; i < full_share_len ; i++) - { - if(full_share[i] == '/') - full_share[i] = '\\'; - } + for(i = 0 ; i < full_share_len ; i++) + { + if(full_share[i] == '/') + full_share[i] = '\\'; + } - StringToUpper(full_share); + StringToUpper(full_share); - SHOWSTRING(full_share); + SHOWSTRING(full_share); - memset (packet, 0, SMB_HEADER_LEN); + memset (packet, 0, SMB_HEADER_LEN); - smb_setup_header (server, SMBtconX, 4, password_len + full_share_len+1 + strlen(dev)+1); + smb_setup_header (server, SMBtconX, 4, password_len + full_share_len+1 + strlen(dev)+1); - WSET (packet, smb_vwv0, 0xFF); - WSET (packet, smb_vwv3, password_len); + WSET (packet, smb_vwv0, 0xFF); + WSET (packet, smb_vwv3, password_len); - p = SMB_BUF (packet); + p = SMB_BUF (packet); - if(nt_password_len > 0) - memcpy(p,password,password_len); - else - memcpy (p, server->mount_data.password, password_len); + if(nt_password_len > 0) + memcpy(p,password,password_len); + else + memcpy (p, server->mount_data.password, password_len); - p += password_len; + p += password_len; - memcpy(p,full_share,full_share_len+1); - p += full_share_len+1; + memcpy(p,full_share,full_share_len+1); + p += full_share_len+1; - strcpy(p,dev); + strcpy(p,dev); - BSET(packet,smb_rcls,1); + BSET(packet,smb_rcls,1); - if ((result = smb_request_ok (server, SMBtconX, 3, 0)) < 0) - { - SHOWVALUE(SMB_WCT(packet)); + if ((result = smb_request_ok (server, SMBtconX, 3, 0)) < 0) + { + SHOWVALUE(SMB_WCT(packet)); - LOG (("smb_proc_connect: SMBtconX not verified.\n")); - goto fail; - } + LOG (("smb_proc_connect: SMBtconX not verified.\n")); + goto fail; + } - SHOWVALUE(SMB_WCT(packet)); + SHOWVALUE(SMB_WCT(packet)); - /* Changed, max_xmit hasn't been updated if a tconX message was send instead of tcon. */ - if (server_maxxmt != 0) - server->max_xmit = server_maxxmt; + /* Changed, max_xmit hasn't been updated if a tconX message was send instead of tcon. */ + if (server_maxxmt != 0) + server->max_xmit = server_maxxmt; - server->tid = WVAL(packet,smb_tid); - } - else - { - word decoded_max_xmit; + server->tid = WVAL(packet,smb_tid); + } + else + { + word decoded_max_xmit; - /* Fine! We have a connection, send a tcon message. */ - smb_setup_header (server, SMBtcon, 0, 6 + strlen (server->mount_data.service) + strlen (server->mount_data.password) + strlen (dev)); + /* Fine! We have a connection, send a tcon message. */ + smb_setup_header (server, SMBtcon, 0, 6 + strlen (server->mount_data.service) + strlen (server->mount_data.password) + strlen (dev)); - p = SMB_BUF (packet); - p = smb_encode_ascii (p, server->mount_data.service, strlen (server->mount_data.service)); - p = smb_encode_ascii (p, server->mount_data.password, strlen (server->mount_data.password)); - (void) smb_encode_ascii (p, dev, strlen (dev)); + p = SMB_BUF (packet); + p = smb_encode_ascii (p, server->mount_data.service, strlen (server->mount_data.service)); + p = smb_encode_ascii (p, server->mount_data.password, strlen (server->mount_data.password)); + (void) smb_encode_ascii (p, dev, strlen (dev)); - if ((result = smb_request_ok (server, SMBtcon, 2, 0)) < 0) - { - LOG (("smb_proc_connect: SMBtcon not verified.\n")); - goto fail; - } + if ((result = smb_request_ok (server, SMBtcon, 2, 0)) < 0) + { + LOG (("smb_proc_connect: SMBtcon not verified.\n")); + goto fail; + } - LOG (("OK! Managed to set up SMBtcon!\n")); + LOG (("OK! Managed to set up SMBtcon!\n")); - p = SMB_VWV (packet); - p = smb_decode_word (p, &decoded_max_xmit); + p = SMB_VWV (packet); + p = smb_decode_word (p, &decoded_max_xmit); - server->max_xmit = decoded_max_xmit; + server->max_xmit = decoded_max_xmit; - SHOWVALUE(server->max_xmit); + SHOWVALUE(server->max_xmit); - /* Added by Brian Willette - We were ignoring the server's initial - maxbuf value */ - if (server_maxxmt != 0 && server->max_xmit > server_maxxmt) - server->max_xmit = server_maxxmt; + /* Added by Brian Willette - We were ignoring the server's initial + maxbuf value */ + if (server_maxxmt != 0 && server->max_xmit > server_maxxmt) + server->max_xmit = server_maxxmt; - (void) smb_decode_word (p, &server->tid); - } + (void) smb_decode_word (p, &server->tid); + } - SHOWVALUE(server->max_xmit); + SHOWVALUE(server->max_xmit); - /* Ok, everything is fine. max_xmit does not include - the TCP-SMB header of 4 bytes. */ - if (server->max_xmit < 65535 - 4) - server->max_xmit += 4; + /* Ok, everything is fine. max_xmit does not include + the TCP-SMB header of 4 bytes. */ + if (server->max_xmit < 65535 - 4) + server->max_xmit += 4; - /* Changed, max_xmit hasn't been updated if a tconX message was send instead of tcon. */ - if (server->max_xmit > given_max_xmit) - server->max_xmit = given_max_xmit; + /* Changed, max_xmit hasn't been updated if a tconX message was send instead of tcon. */ + if (server->max_xmit > given_max_xmit) + server->max_xmit = given_max_xmit; - LOG (("max_xmit = %ld, tid = %ld\n", server->max_xmit, server->tid)); + LOG (("max_xmit = %ld, tid = %ld\n", server->max_xmit, server->tid)); - LOG (("smb_proc_connect: Normal exit\n")); + LOG (("smb_proc_connect: Normal exit\n")); - return 0; + return 0; fail: - server->state = CONN_INVALID; + server->state = CONN_INVALID; - return result; + return result; } /* smb_proc_reconnect: server->packet is allocated with @@ -2531,182 +2528,182 @@ smb_proc_reconnect (struct smb_server *server) int smb_proc_connect (struct smb_server *server) { - int result; + int result; - result = smb_proc_reconnect (server); + result = smb_proc_reconnect (server); - if ((result < 0) && (server->packet != NULL)) - { - free (server->packet); - server->packet = NULL; - } + if ((result < 0) && (server->packet != NULL)) + { + free (server->packet); + server->packet = NULL; + } - return result; + return result; } /* error code stuff - put together by Merik Karman merik -at- blackadder -dot- dsh -dot- oz -dot- au */ typedef struct { - char *name; - int code; - char *message; + char *name; + int code; + char *message; } err_code_struct; /* Dos Error Messages */ static const err_code_struct dos_msgs[] = { - {"ERRbadfunc", 1, "Invalid function"}, - {"ERRbadfile", 2, "File not found"}, - {"ERRbadpath", 3, "Directory invalid"}, - {"ERRnofids", 4, "No file descriptors available"}, - {"ERRnoaccess", 5, "Access denied"}, - {"ERRbadfid", 6, "Invalid file handle"}, - {"ERRbadmcb", 7, "Memory control blocks destroyed"}, - {"ERRnomem", 8, "Insufficient server memory to perform the requested function"}, - {"ERRbadmem", 9, "Invalid memory block address"}, - {"ERRbadenv", 10, "Invalid environment"}, - {"ERRbadformat", 11, "Invalid format"}, - {"ERRbadaccess", 12, "Invalid open mode"}, - {"ERRbaddata", 13, "Invalid data"}, - {"ERR", 14, "reserved"}, - {"ERRbaddrive", 15, "Invalid drive specified"}, - {"ERRremcd", 16, "A Delete Directory request attempted to remove the server's current directory"}, - {"ERRdiffdevice", 17, "Not same device"}, - {"ERRnofiles", 18, "A File Search command can find no more files matching the specified criteria"}, - {"ERRbadshare", 32, "The sharing mode specified for an Open conflicts with existing FIDs on the file"}, - {"ERRlock", 33, "A Lock request conflicted with an existing lock or specified an invalid mode, or an Unlock requested attempted to remove a lock held by another process"}, - {"ERRnosuchshare", 67, "Share name not found"}, - {"ERRfilexists", 80, "The file named in a Create Directory, Make New File or Link request already exists"}, - {"ERRbadpipe", 230, "Pipe invalid"}, - {"ERRpipebusy", 231, "All instances of the requested pipe are busy"}, - {"ERRpipeclosing", 232, "Pipe close in progress"}, - {"ERRnotconnected", 233, "No process on other end of pipe"}, - {"ERRmoredata", 234, "There is more data to be returned"}, + {"ERRbadfunc", 1, "Invalid function"}, + {"ERRbadfile", 2, "File not found"}, + {"ERRbadpath", 3, "Directory invalid"}, + {"ERRnofids", 4, "No file descriptors available"}, + {"ERRnoaccess", 5, "Access denied"}, + {"ERRbadfid", 6, "Invalid file handle"}, + {"ERRbadmcb", 7, "Memory control blocks destroyed"}, + {"ERRnomem", 8, "Insufficient server memory to perform the requested function"}, + {"ERRbadmem", 9, "Invalid memory block address"}, + {"ERRbadenv", 10, "Invalid environment"}, + {"ERRbadformat", 11, "Invalid format"}, + {"ERRbadaccess", 12, "Invalid open mode"}, + {"ERRbaddata", 13, "Invalid data"}, + {"ERR", 14, "reserved"}, + {"ERRbaddrive", 15, "Invalid drive specified"}, + {"ERRremcd", 16, "A Delete Directory request attempted to remove the server's current directory"}, + {"ERRdiffdevice", 17, "Not same device"}, + {"ERRnofiles", 18, "A File Search command can find no more files matching the specified criteria"}, + {"ERRbadshare", 32, "The sharing mode specified for an Open conflicts with existing FIDs on the file"}, + {"ERRlock", 33, "A Lock request conflicted with an existing lock or specified an invalid mode, or an Unlock requested attempted to remove a lock held by another process"}, + {"ERRnosuchshare", 67, "Share name not found"}, + {"ERRfilexists", 80, "The file named in a Create Directory, Make New File or Link request already exists"}, + {"ERRbadpipe", 230, "Pipe invalid"}, + {"ERRpipebusy", 231, "All instances of the requested pipe are busy"}, + {"ERRpipeclosing", 232, "Pipe close in progress"}, + {"ERRnotconnected", 233, "No process on other end of pipe"}, + {"ERRmoredata", 234, "There is more data to be returned"}, - {NULL, -1, NULL} + {NULL, -1, NULL} }; /* Server Error Messages */ static const err_code_struct server_msgs[] = { - {"ERRerror", 1, "Non-specific error code"}, - {"ERRbadpw", 2, "Bad password - name/password pair in a Tree Connect or Session Setup are invalid"}, - {"ERRbadtype", 3, "reserved"}, - {"ERRaccess", 4, "The requester does not have the necessary access rights within the specified context for the requested function. The context is defined by the TID or the UID"}, - {"ERRinvnid", 5, "The tree ID (TID) specified in a command was invalid"}, - {"ERRinvnetname", 6, "Invalid network name in tree connect"}, - {"ERRinvdevice", 7, "Invalid device - printer request made to non-printer connection or non-printer request made to printer connection"}, - {"ERRqfull", 49, "Print queue full (files) -- returned by open print file"}, - {"ERRqtoobig", 50, "Print queue full -- no space"}, - {"ERRqeof", 51, "EOF on print queue dump"}, - {"ERRinvpfid", 52, "Invalid print file FID"}, - {"ERRsmbcmd", 64, "The server did not recognize the command received"}, - {"ERRsrverror", 65, "The server encountered an internal error, e.g., system file unavailable"}, - {"ERRfilespecs", 67, "The file handle (FID) and pathname parameters contained an invalid combination of values"}, - {"ERRreserved", 68, "reserved"}, - {"ERRbadpermits", 69, "The access permissions specified for a file or directory are not a valid combination. The server cannot set the requested attribute"}, - {"ERRreserved", 70, "reserved"}, - {"ERRsetattrmode", 71, "The attribute mode in the Set File Attribute request is invalid"}, - {"ERRpaused", 81, "Server is paused"}, - {"ERRmsgoff", 82, "Not receiving messages"}, - {"ERRnoroom", 83, "No room to buffer message"}, - {"ERRrmuns", 87, "Too many remote user names"}, - {"ERRtimeout", 88, "Operation timed out"}, - {"ERRnoresource", 89, "No resources currently available for request"}, - {"ERRtoomanyuids", 90, "Too many UIDs active on this session"}, - {"ERRbaduid", 91, "The UID is not known as a valid ID on this session"}, - {"ERRusempx", 250, "Temp unable to support Raw, use MPX mode"}, - {"ERRusestd", 251, "Temp unable to support Raw, use standard read/write"}, - {"ERRcontmpx", 252, "Continue in MPX mode"}, - {"ERRreserved", 253, "reserved"}, - {"ERRreserved", 254, "reserved"}, - {"ERRnosupport", 0xFFFF, "Function not supported"}, + {"ERRerror", 1, "Non-specific error code"}, + {"ERRbadpw", 2, "Bad password - name/password pair in a Tree Connect or Session Setup are invalid"}, + {"ERRbadtype", 3, "reserved"}, + {"ERRaccess", 4, "The requester does not have the necessary access rights within the specified context for the requested function. The context is defined by the TID or the UID"}, + {"ERRinvnid", 5, "The tree ID (TID) specified in a command was invalid"}, + {"ERRinvnetname", 6, "Invalid network name in tree connect"}, + {"ERRinvdevice", 7, "Invalid device - printer request made to non-printer connection or non-printer request made to printer connection"}, + {"ERRqfull", 49, "Print queue full (files) -- returned by open print file"}, + {"ERRqtoobig", 50, "Print queue full -- no space"}, + {"ERRqeof", 51, "EOF on print queue dump"}, + {"ERRinvpfid", 52, "Invalid print file FID"}, + {"ERRsmbcmd", 64, "The server did not recognize the command received"}, + {"ERRsrverror", 65, "The server encountered an internal error, e.g., system file unavailable"}, + {"ERRfilespecs", 67, "The file handle (FID) and pathname parameters contained an invalid combination of values"}, + {"ERRreserved", 68, "reserved"}, + {"ERRbadpermits", 69, "The access permissions specified for a file or directory are not a valid combination. The server cannot set the requested attribute"}, + {"ERRreserved", 70, "reserved"}, + {"ERRsetattrmode", 71, "The attribute mode in the Set File Attribute request is invalid"}, + {"ERRpaused", 81, "Server is paused"}, + {"ERRmsgoff", 82, "Not receiving messages"}, + {"ERRnoroom", 83, "No room to buffer message"}, + {"ERRrmuns", 87, "Too many remote user names"}, + {"ERRtimeout", 88, "Operation timed out"}, + {"ERRnoresource", 89, "No resources currently available for request"}, + {"ERRtoomanyuids", 90, "Too many UIDs active on this session"}, + {"ERRbaduid", 91, "The UID is not known as a valid ID on this session"}, + {"ERRusempx", 250, "Temp unable to support Raw, use MPX mode"}, + {"ERRusestd", 251, "Temp unable to support Raw, use standard read/write"}, + {"ERRcontmpx", 252, "Continue in MPX mode"}, + {"ERRreserved", 253, "reserved"}, + {"ERRreserved", 254, "reserved"}, + {"ERRnosupport", 0xFFFF, "Function not supported"}, - {NULL, -1, NULL} + {NULL, -1, NULL} }; /* Hard Error Messages */ static const err_code_struct hard_msgs[] = { - {"ERRnowrite", 19, "Attempt to write on write-protected diskette"}, - {"ERRbadunit", 20, "Unknown unit"}, - {"ERRnotready", 21, "Drive not ready"}, - {"ERRbadcmd", 22, "Unknown command"}, - {"ERRdata", 23, "Data error (CRC)"}, - {"ERRbadreq", 24, "Bad request structure length"}, - {"ERRseek", 25, "Seek error"}, - {"ERRbadmedia", 26, "Unknown media type"}, - {"ERRbadsector", 27, "Sector not found"}, - {"ERRnopaper", 28, "Printer out of paper"}, - {"ERRwrite", 29, "Write fault"}, - {"ERRread", 30, "Read fault"}, - {"ERRgeneral", 31, "General failure"}, - {"ERRbadshare", 32, "A open conflicts with an existing open"}, - {"ERRlock", 33, "A Lock request conflicted with an existing lock or specified an invalid mode, or an Unlock requested attempted to remove a lock held by another process"}, - {"ERRwrongdisk", 34, "The wrong disk was found in a drive"}, - {"ERRFCBUnavail", 35, "No FCBs are available to process request"}, - {"ERRsharebufexc", 36, "A sharing buffer has been exceeded"}, + {"ERRnowrite", 19, "Attempt to write on write-protected diskette"}, + {"ERRbadunit", 20, "Unknown unit"}, + {"ERRnotready", 21, "Drive not ready"}, + {"ERRbadcmd", 22, "Unknown command"}, + {"ERRdata", 23, "Data error (CRC)"}, + {"ERRbadreq", 24, "Bad request structure length"}, + {"ERRseek", 25, "Seek error"}, + {"ERRbadmedia", 26, "Unknown media type"}, + {"ERRbadsector", 27, "Sector not found"}, + {"ERRnopaper", 28, "Printer out of paper"}, + {"ERRwrite", 29, "Write fault"}, + {"ERRread", 30, "Read fault"}, + {"ERRgeneral", 31, "General failure"}, + {"ERRbadshare", 32, "A open conflicts with an existing open"}, + {"ERRlock", 33, "A Lock request conflicted with an existing lock or specified an invalid mode, or an Unlock requested attempted to remove a lock held by another process"}, + {"ERRwrongdisk", 34, "The wrong disk was found in a drive"}, + {"ERRFCBUnavail", 35, "No FCBs are available to process request"}, + {"ERRsharebufexc", 36, "A sharing buffer has been exceeded"}, - {NULL, -1, NULL} + {NULL, -1, NULL} }; typedef struct { - int code; - char *class; - const err_code_struct *err_msgs; + int code; + char *class; + const err_code_struct *err_msgs; } err_class_struct; static const err_class_struct err_classes[] = { - { 0, "SUCCESS", NULL }, - { 0x01, "ERRDOS", dos_msgs }, - { 0x02, "ERRSRV", server_msgs }, - { 0x03, "ERRHRD", hard_msgs }, - { 0x04, "ERRXOS", NULL }, - { 0xE1, "ERRRMX1", NULL }, - { 0xE2, "ERRRMX2", NULL }, - { 0xE3, "ERRRMX3", NULL }, - { 0xFF, "ERRCMD", NULL }, + { 0, "SUCCESS", NULL }, + { 0x01, "ERRDOS", dos_msgs }, + { 0x02, "ERRSRV", server_msgs }, + { 0x03, "ERRHRD", hard_msgs }, + { 0x04, "ERRXOS", NULL }, + { 0xE1, "ERRRMX1", NULL }, + { 0xE2, "ERRRMX2", NULL }, + { 0xE3, "ERRRMX3", NULL }, + { 0xFF, "ERRCMD", NULL }, - { -1, NULL, NULL } + { -1, NULL, NULL } }; static void smb_printerr (int class, int num) { - int i, j; - err_code_struct *err; + int i, j; + err_code_struct *err; - for (i = 0; err_classes[i].class; i++) - { - if (err_classes[i].code != class) - continue; + for (i = 0; err_classes[i].class; i++) + { + if (err_classes[i].code != class) + continue; - if (!err_classes[i].err_msgs) - { - ReportError("%s - %ld.", err_classes[i].class, num); + if (!err_classes[i].err_msgs) + { + ReportError("%s - %ld.", err_classes[i].class, num); - LOG (("%s - %ld\n", err_classes[i].class, num)); - return; - } + LOG (("%s - %ld\n", err_classes[i].class, num)); + return; + } - err = (err_code_struct *)err_classes[i].err_msgs; + err = (err_code_struct *)err_classes[i].err_msgs; - for (j = 0; err[j].name; j++) - { - if (num != err[j].code) - continue; + for (j = 0; err[j].name; j++) + { + if (num != err[j].code) + continue; - ReportError ("%s - %s (%s).", err_classes[i].class, err[j].name, err[j].message); + ReportError ("%s - %s (%s).", err_classes[i].class, err[j].name, err[j].message); - LOG (("%s - %s (%s)\n",err_classes[i].class, err[j].name,err[j].message)); - return; - } - } + LOG (("%s - %s (%s)\n",err_classes[i].class, err[j].name,err[j].message)); + return; + } + } - ReportError ("Unknown error - (%ld, %ld).", class, num); + ReportError ("Unknown error - (%ld, %ld).", class, num); - LOG (("Unknown error - (%ld, %ld)\n", class, num)); + LOG (("Unknown error - (%ld, %ld)\n", class, num)); }