file.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 1996-2017 The Squid Software Foundation and contributors
3  *
4  * Squid software is distributed under GPLv2+ license and includes
5  * contributions from numerous individuals and organizations.
6  * Please see the COPYING and CONTRIBUTORS files for details.
7  */
8 
9 /* UNIX SMBlib NetBIOS implementation
10 
11  Version 1.0
12  SMBlib File Access Routines
13 
14  Copyright (C) Richard Sharpe 1996
15 */
16 
17 /*
18  This program is free software; you can redistribute it and/or modify
19  it under the terms of the GNU General Public License as published by
20  the Free Software Foundation; either version 2 of the License, or
21  (at your option) any later version.
22 
23  This program is distributed in the hope that it will be useful,
24  but WITHOUT ANY WARRANTY; without even the implied warranty of
25  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26  GNU General Public License for more details.
27 
28  You should have received a copy of the GNU General Public License
29  along with this program; if not, write to the Free Software
30  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31 */
32 
33 #include "squid.h"
34 #include "rfcnb/rfcnb.h"
35 #include "smblib/smblib-priv.h"
36 
37 #if HAVE_STRING_H
38 #include <string.h>
39 #endif
40 
41 /* Open a file with file_name using desired mode and search attr */
42 /* If File_Handle is null, then create and populate a file handle */
43 
45  SMB_File *File_Handle,
46  char *file_name,
47  WORD mode,
48  WORD search)
49 
50 {
51  struct RFCNB_Pkt *pkt;
52  int pkt_len, param_len;
53  char *p;
54  struct SMB_File_Def *file_tmp;
55 
56  /* We allocate a file object and copy some things ... */
57 
58  file_tmp = File_Handle;
59 
60  if (File_Handle == NULL) {
61 
62  if ((file_tmp = (SMB_File *)malloc(sizeof(SMB_File))) == NULL) {
63 
64 #ifdef DEBUG
65  fprintf(stderr, "Could not allocate file handle space ...");
66 #endif
67 
69  return(NULL);
70 
71  }
72 
73  }
74 
75  strncpy(file_tmp -> filename, file_name, sizeof(file_tmp -> filename) - 1);
76  file_tmp -> tree = Tree_Handle;
77  file_tmp -> fid = 0xFFFF; /* Is this an invalid FID? */
78 
79  param_len = strlen(file_name) + 2; /* 1 for null, 1 for ASCII marker */
80 
81  pkt_len = SMB_open_len + param_len;
82 
83  pkt = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(max(pkt_len, SMB_openr_len));
84 
85  if (pkt == NULL) { /* Really should do some error handling */
86 
87  if (File_Handle == NULL)
88  free(file_tmp);
90  return(NULL);
91 
92  }
93 
94  /* Now plug in the bits we need */
95 
96  memset(SMB_Hdr(pkt), 0, SMB_open_len);
97  SIVAL(SMB_Hdr(pkt), SMB_hdr_idf_offset, SMB_DEF_IDF); /* Plunk in IDF */
99  SSVAL(SMB_Hdr(pkt), SMB_hdr_pid_offset, Tree_Handle -> con -> pid);
100  SSVAL(SMB_Hdr(pkt), SMB_hdr_tid_offset, Tree_Handle -> tid);
101  SSVAL(SMB_Hdr(pkt), SMB_hdr_mid_offset, Tree_Handle -> con -> mid);
102  SSVAL(SMB_Hdr(pkt), SMB_hdr_uid_offset, Tree_Handle -> con -> uid);
103  *(SMB_Hdr(pkt) + SMB_hdr_wct_offset) = 2;
104 
105  SSVAL(SMB_Hdr(pkt), SMB_open_mod_offset, mode);
106  SSVAL(SMB_Hdr(pkt), SMB_open_atr_offset, search);
107  SSVAL(SMB_Hdr(pkt), SMB_open_bcc_offset, param_len);
108 
109  /* Now plug in the file name ... */
110 
111  p = (char *)(SMB_Hdr(pkt) + SMB_open_buf_offset);
112  *p = SMBasciiID;
113  strcpy(p+1, file_name);
114  p = p + strlen(file_name);
115  *(p+1) = 0; /* plug in a null ... */
116 
117  /* Now send the packet and get the response ... */
118 
119  if (RFCNB_Send(Tree_Handle -> con -> Trans_Connect, pkt, pkt_len) < 0) {
120 
121 #ifdef DEBUG
122  fprintf(stderr, "Error sending Open request\n");
123 #endif
124 
125  if (File_Handle == NULL)
126  free(file_tmp);
127  RFCNB_Free_Pkt(pkt);
129  return(NULL);
130 
131  }
132 
133  /* Now get the response ... */
134 
135 #ifdef DEBUG
136  fprintf(stderr, "Pkt_Len for Open resp = %i\n", pkt_len);
137 #endif
138 
139  if (RFCNB_Recv(Tree_Handle -> con -> Trans_Connect, pkt, pkt_len) < 0) {
140 
141 #ifdef DEBUG
142  fprintf(stderr, "Error receiving response to open request\n");
143 #endif
144 
145  if (File_Handle = NULL)
146  free(file_tmp);
147  RFCNB_Free_Pkt(pkt);
149  return(NULL);
150 
151  }
152 
153  /* Now parse the response and pass back any error ... */
154 
155  if (CVAL(SMB_Hdr(pkt), SMB_hdr_rcls_offset) != SMBC_SUCCESS) { /* Process error */
156 
157 #ifdef DEBUG
158  fprintf(stderr, "SMB_Open failed with errorclass = %i, Error Code = %i\n",
161 #endif
162 
163  if (File_Handle = NULL)
164  free(file_tmp);
166  RFCNB_Free_Pkt(pkt);
168  return(NULL); /* Should clean up ... */
169 
170  }
171 
172  file_tmp -> fid = SVAL(SMB_Hdr(pkt), SMB_openr_fid_offset);
173  file_tmp -> lastmod = IVAL(SMB_Hdr(pkt), SMB_openr_tim_offset);
174  file_tmp -> size = IVAL(SMB_Hdr(pkt), SMB_openr_fsz_offset);
175  file_tmp -> access = SVAL(SMB_Hdr(pkt), SMB_openr_acc_offset);
176  file_tmp -> fileloc = 0;
177 
178  RFCNB_Free_Pkt(pkt); /* Free up this space */
179 
180 #ifdef DEBUG
181  fprintf(stderr, "SMB_Open succeeded, FID = %i\n", file_tmp -> fid);
182 #endif
183 
184  RFCNB_Free_Pkt(pkt);
185 
186  return(file_tmp);
187 
188 }
189 
190 /* Close the file referred to in File_Handle */
191 
192 int SMB_Close(SMB_File *File_Handle)
193 
194 {
195  struct SMB_Close_Prot_Def *prot_pkt;
196  struct SMB_Hdr_Def_LM12 *resp_pkt;
197  struct RFCNB_Pkt *pkt;
198  int pkt_len;
199 
200  if (File_Handle == NULL) { /* Error */
201 
202  /*SMBLIB_errno = SMBLIBE_BadHandle; */
203  return(-1);
204 
205  }
206 
207  pkt_len = SMB_clos_len;
208 
209  pkt = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(pkt_len);
210 
211  if (pkt == NULL) { /* Really should do some error handling */
212 
214  return(SMBlibE_BAD);
215 
216  }
217 
218  /* Now plug in the bits we need */
219 
220  memset(SMB_Hdr(pkt), 0, SMB_clos_len);
221  SIVAL(SMB_Hdr(pkt), SMB_hdr_idf_offset, SMB_DEF_IDF); /* Plunk in IDF */
222  *(SMB_Hdr(pkt) + SMB_hdr_com_offset) = SMBclose;
223  SSVAL(SMB_Hdr(pkt), SMB_hdr_pid_offset, File_Handle -> tree -> con -> pid);
224  SSVAL(SMB_Hdr(pkt), SMB_hdr_tid_offset, File_Handle -> tree -> tid);
225  SSVAL(SMB_Hdr(pkt), SMB_hdr_mid_offset, File_Handle -> tree -> con -> mid);
226  SSVAL(SMB_Hdr(pkt), SMB_hdr_uid_offset, File_Handle -> tree -> con -> uid);
227  *(SMB_Hdr(pkt) + SMB_hdr_wct_offset) = 3;
228 
229  SSVAL(SMB_Hdr(pkt), SMB_clos_fid_offset, File_Handle -> fid);
232 
233  /* Now send the packet and get the response ... */
234 
235  if (RFCNB_Send(File_Handle -> tree -> con -> Trans_Connect, pkt, pkt_len) < 0) {
236 
237 #ifdef DEBUG
238  fprintf(stderr, "Error sending Open request\n");
239 #endif
240 
241  RFCNB_Free_Pkt(pkt);
243  return(SMBlibE_BAD);
244 
245  }
246 
247  /* Now get the response ... */
248 
249  if (RFCNB_Recv(File_Handle -> tree -> con -> Trans_Connect, pkt, pkt_len) < 0) {
250 
251 #ifdef DEBUG
252  fprintf(stderr, "Error receiving response to open request\n");
253 #endif
254 
255  RFCNB_Free_Pkt(pkt);
257  return(SMBlibE_BAD);
258 
259  }
260 
261  /* Now parse the response and pass back any error ... */
262 
263  if (CVAL(SMB_Hdr(pkt), SMB_hdr_rcls_offset) != SMBC_SUCCESS) { /* Process error */
264 
265 #ifdef DEBUG
266  fprintf(stderr, "SMB_Close failed with errorclass = %i, Error Code = %i\n",
269 #endif
270 
272  RFCNB_Free_Pkt(pkt);
274  return(SMBlibE_BAD); /* Should clean up ... */
275 
276  }
277 
278 #ifdef DEBUG
279  fprintf(stderr, "File %s closed successfully.\n", File_Handle -> filename);
280 #endif DEBUG
281 
282  /* We should deallocate the File_Handle now ... */
283 
284  File_Handle -> tree = NULL;
285  File_Handle -> filename[0] = 0;
286  File_Handle -> fid = 0xFFFF;
287 
288  RFCNB_Free_Pkt(pkt);
289  free(File_Handle);
290 
291  return(0);
292 }
293 
294 /* Read numbytes into data from the file pointed to by File_Handle from */
295 /* the offset in the File_Handle. */
296 
297 int SMB_Read(SMB_File *File_Handle, char *data, int numbytes)
298 
299 {
300  int tot_read;
301  struct RFCNB_Pkt *snd_pkt, *recv_pkt, *data_ptr;
302  int snd_pkt_len, recv_pkt_len, this_read, bytes_left = numbytes;
303  int max_read_data, bytes_read = 0;
304 
305  /* We loop around, reading the data, accumulating it into the buffer */
306  /* We build an SMB packet, where the data is pointed to by a fragment*/
307  /* tagged onto the end */
308 
309  data_ptr = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(0);
310  if (data_ptr == NULL) {
311 
312  /* We should handle the error here */
313 
315  return(SMBlibE_BAD);
316 
317  }
318 
319  snd_pkt_len = SMB_read_len; /* size for the read SMB */
320  recv_pkt_len = SMB_readr_len + 3; /* + 3 for the datablockID and blklen */
321 
322  snd_pkt = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(snd_pkt_len);
323 
324  if (snd_pkt == NULL) {
325 
326  RFCNB_Free_Pkt(data_ptr);
328  return(SMBlibE_BAD);
329 
330  }
331 
332  recv_pkt = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(recv_pkt_len);
333 
334  if (recv_pkt == NULL) {
335 
336  RFCNB_Free_Pkt(snd_pkt);
337  RFCNB_Free_Pkt(data_ptr);
339  return(SMBlibE_BAD);
340 
341  }
342 
343  /* Put the recv pkt together */
344 
345  recv_pkt -> next = data_ptr;
346 
347  /* Now build the read request and the receive packet etc ... */
348 
349  memset(SMB_Hdr(snd_pkt), 0, SMB_read_len);
350  SIVAL(SMB_Hdr(snd_pkt), SMB_hdr_idf_offset, SMB_DEF_IDF); /* Plunk in IDF */
351  *(SMB_Hdr(snd_pkt) + SMB_hdr_com_offset) = SMBread;
352  SSVAL(SMB_Hdr(snd_pkt), SMB_hdr_pid_offset, File_Handle -> tree -> con -> pid);
353  SSVAL(SMB_Hdr(snd_pkt), SMB_hdr_tid_offset, File_Handle -> tree -> tid);
354  SSVAL(SMB_Hdr(snd_pkt), SMB_hdr_mid_offset, File_Handle -> tree -> con -> mid);
355  SSVAL(SMB_Hdr(snd_pkt), SMB_hdr_uid_offset, File_Handle -> tree -> con -> uid);
356  *(SMB_Hdr(snd_pkt) + SMB_hdr_wct_offset) = 5;
357  SSVAL(SMB_Hdr(snd_pkt), SMB_read_fid_offset, File_Handle -> fid);
358 
359  max_read_data = (File_Handle -> tree -> mbs) - recv_pkt_len;
360 
361  while (bytes_left > 0) {
362 
363  this_read = (bytes_left > max_read_data?max_read_data: bytes_left);
364 
365  SSVAL(SMB_Hdr(snd_pkt), SMB_read_cnt_offset, this_read);
366  SIVAL(SMB_Hdr(snd_pkt), SMB_read_ofs_offset, File_Handle -> fileloc);
367  SSVAL(SMB_Hdr(snd_pkt), SMB_read_clf_offset, 0x0);
368  SSVAL(SMB_Hdr(snd_pkt), SMB_read_bcc_offset, 0x0);
369 
370  /* Now send the packet and wait for a response */
371 
372  if (RFCNB_Send(File_Handle -> tree -> con -> Trans_Connect, snd_pkt, snd_pkt_len) < 0) {
373 
374 #ifdef DEBUG
375  fprintf(stderr, "Error sending read request\n");
376 #endif
377 
378  data_ptr -> data = NULL;
379  data_ptr -> len = 0;
380  RFCNB_Free_Pkt(recv_pkt);
381  RFCNB_Free_Pkt(snd_pkt);
383  return(SMBlibE_BAD);
384 
385  }
386 
387  /* Now get the response ... first point the data portion to the right */
388  /* place in the read buffer ... what we are doing is ugly */
389 
390  data_ptr -> data = (data + bytes_read);
391  data_ptr -> len = this_read;
392 
393  if (RFCNB_Recv(File_Handle -> tree -> con -> Trans_Connect, recv_pkt, recv_pkt_len + this_read) < 0) {
394 
395 #ifdef DEBUG
396  fprintf(stderr, "Error receiving response to write\n");
397 #endif
398 
399  data_ptr -> len = 0;
400  data_ptr -> data = NULL;
401  RFCNB_Free_Pkt(recv_pkt);
402  RFCNB_Free_Pkt(snd_pkt);
404  return(SMBlibE_BAD);
405 
406  }
407 
408  if (CVAL(SMB_Hdr(recv_pkt), SMB_hdr_rcls_offset) != SMBC_SUCCESS) { /* Process error */
409 
410 #ifdef DEBUG
411  fprintf(stderr, "SMB_Read failed with errorclass = %i, Error Code = %i\n",
412  CVAL(SMB_Hdr(recv_pkt), SMB_hdr_rcls_offset),
413  SVAL(SMB_Hdr(recv_pkt), SMB_hdr_err_offset));
414 #endif
415 
417  data_ptr -> data = NULL;
418  data_ptr -> len = 0;
419  RFCNB_Free_Pkt(recv_pkt);
420  RFCNB_Free_Pkt(snd_pkt);
422  return(-1);
423 
424  }
425 
426  /* Ok, that worked, so update some things here ... */
427 
428  bytes_read = bytes_read + SVAL(SMB_Hdr(recv_pkt), SMB_readr_cnt_offset);
429  bytes_left = bytes_left - SVAL(SMB_Hdr(recv_pkt), SMB_readr_cnt_offset);
430 
431  }
432 
433  /* Now free those packet headers that we allocated ... */
434 
435  data_ptr -> data = NULL; /* Since recv_pkt points to data_ptr */
436  data_ptr -> len = 0; /* it is freed too */
437  RFCNB_Free_Pkt(recv_pkt);
438  RFCNB_Free_Pkt(snd_pkt);
439 
440  return(bytes_read);
441 
442 }
443 
444 /* Lseek seeks just like the UNIX version does ... */
445 
446 off_t SMB_Lseek(SMB_File *File_Handle, off_t offset, int whence)
447 
448 {
449 
450  /* We should check that the file handle is kosher ... We may also blow up
451  if we get a 64 bit offset ... should avoid wrap-around ... */
452 
453  switch (whence) {
454  case SEEK_SET:
455 
456  File_Handle -> fileloc = offset;
457  break;
458 
459  case SEEK_CUR:
460 
461  File_Handle -> fileloc = File_Handle -> fileloc + offset;
462  break;
463 
464  case SEEK_END:
465 
466  File_Handle -> fileloc = File_Handle -> size + offset;
467  break;
468 
469  default:
470  return(-1);
471 
472  }
473 
474  return(File_Handle -> fileloc);
475 
476 }
477 
478 /* Write numbytes from data to the file pointed to by the File_Handle at */
479 /* the offset in the File_Handle. */
480 
481 int SMB_Write(SMB_File *File_Handle, char *data, int numbytes)
482 
483 {
484  int tot_written = 0;
485  struct RFCNB_Pkt *pkt, *data_ptr;
486  int pkt_len, i, this_write, max_write_data, bytes_left = numbytes;
487 
488  /* We loop around, writing the data, accumulating what was written */
489  /* We build an SMB packet, where the data is pointed to by a fragment */
490  /* tagged onto the end ... */
491 
492  data_ptr = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(0);
493  if (data_ptr == NULL) {
494 
496  return(SMBlibE_BAD);
497 
498  }
499 
500  pkt_len = SMB_write_len + 3; /* + 3 for the datablockID and blklen */
501 
502  pkt = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(pkt_len);
503 
504  if (pkt == NULL) {
505 
506  RFCNB_Free_Pkt(data_ptr);
508  return(SMBlibE_BAD);
509 
510  }
511 
512  /* Now init the things that will be the same across the possibly multiple
513  packets to write this data. */
514 
515  memset(SMB_Hdr(pkt), 0, SMB_write_len);
516  SIVAL(SMB_Hdr(pkt), SMB_hdr_idf_offset, SMB_DEF_IDF); /* Plunk in IDF */
517  *(SMB_Hdr(pkt) + SMB_hdr_com_offset) = SMBwrite;
518  SSVAL(SMB_Hdr(pkt), SMB_hdr_pid_offset, File_Handle -> tree -> con -> pid);
519  SSVAL(SMB_Hdr(pkt), SMB_hdr_tid_offset, File_Handle -> tree -> tid);
520  SSVAL(SMB_Hdr(pkt), SMB_hdr_mid_offset, File_Handle -> tree -> con -> mid);
521  SSVAL(SMB_Hdr(pkt), SMB_hdr_uid_offset, File_Handle -> tree -> con -> uid);
522  SSVAL(SMB_Hdr(pkt), SMB_write_fid_offset, File_Handle -> fid);
523 
524  /* We will program this as send/response for the moment, but if we could
525  only send the second block before getting the first, we could speed
526  things up a bit ... */
527 
528  max_write_data = (File_Handle -> tree -> mbs) - pkt_len;
529 
530  /* the 3 is for the data block id and length that preceeds the data */
531 
532  while (bytes_left > 0) {
533 
534  /* bytes to write? */
535 
536  this_write = (bytes_left > max_write_data?max_write_data:bytes_left);
537 
538  data_ptr -> next = NULL;
539  data_ptr -> len = this_write;
540  data_ptr -> data = data + tot_written;
541 
542  pkt -> next = data_ptr; /* link the data on the end */
543 
544  SSVAL(SMB_Hdr(pkt), SMB_hdr_flg_offset, 0);
545  *(SMB_Hdr(pkt) + SMB_hdr_wct_offset) = 5;
546  SSVAL(SMB_Hdr(pkt), SMB_write_fid_offset, File_Handle -> fid);
547  SSVAL(SMB_Hdr(pkt), SMB_write_cnt_offset, this_write);
548  SIVAL(SMB_Hdr(pkt), SMB_write_ofs_offset, File_Handle -> fileloc);
550  SSVAL(SMB_Hdr(pkt), SMB_write_bcc_offset, (this_write + 3));
551 
553  SSVAL(SMB_Hdr(pkt), SMB_write_buf_offset + 1, this_write);
554 
555  /* Now send the packet and wait for a response */
556 
557  if (RFCNB_Send(File_Handle -> tree -> con -> Trans_Connect, pkt, pkt_len + this_write) < 0) {
558 
559 #ifdef DEBUG
560  fprintf(stderr, "Error sending write request\n");
561 #endif
562 
563  data_ptr -> next = NULL;
564  data_ptr -> len = 0;
565  RFCNB_Free_Pkt(pkt);
567  return(-1);
568 
569  }
570 
571  /* Now get the response ... */
572 
573  if (RFCNB_Recv(File_Handle -> tree -> con -> Trans_Connect, pkt, pkt_len) < 0) {
574 
575 #ifdef DEBUG
576  fprintf(stderr, "Error receiving response to write\n");
577 #endif
578 
579  data_ptr -> next = NULL;
580  data_ptr -> len = 0;
581  RFCNB_Free_Pkt(pkt);
583  return(-1);
584 
585  }
586 
587  if (CVAL(SMB_Hdr(pkt), SMB_hdr_rcls_offset) != SMBC_SUCCESS) { /* Process error */
588 
589 #ifdef DEBUG
590  fprintf(stderr, "SMB_Write failed with errorclass = %i, Error Code = %i\n",
593 #endif
594 
596  data_ptr -> data = NULL;
597  data_ptr -> len = 0;
598  RFCNB_Free_Pkt(pkt);
600  return(SMBlibE_BAD);
601 
602  }
603 
604  /* Ok, that worked, so update some things here ... */
605 
606  tot_written = tot_written + this_write;
607  bytes_left = bytes_left - this_write;
608 
609  /* Assume that it is ok to update this now, but what about only part */
610  /* of the write succeeding? */
611 
612  File_Handle -> fileloc = File_Handle -> fileloc + this_write;
613 
614 #ifdef DEBUG
615  fprintf(stderr, "--This_write = %i, bytes_left = %i\n",
616  this_write, bytes_left);
617 #endif
618 
619  }
620 
621  /* Let's get rid of those packet headers we are using ... */
622 
623  data_ptr -> data = NULL;
624  pkt -> next = NULL;
625 
626  RFCNB_Free_Pkt(pkt);
627 
628  return(tot_written);
629 
630 }
631 
632 /* Create file on the server with name file_name and attributes search */
633 
635  SMB_File *File_Handle,
636  char *file_name,
637  WORD search)
638 
639 {
640  struct RFCNB_Pkt *pkt;
641  int pkt_len, param_len;
642  char *p;
643  struct SMB_File_Def *file_tmp;
644 
645  /* We allocate a file object and copy some things ... */
646 
647  file_tmp = File_Handle;
648 
649  if (File_Handle == NULL) {
650 
651  if ((file_tmp = (SMB_File *)malloc(sizeof(SMB_File))) == NULL) {
652 
653 #ifdef DEBUG
654  fprintf(stderr, "Could not allocate file handle space ...");
655 #endif
656 
658  return(NULL);
659 
660  }
661 
662  }
663 
664  strncpy(file_tmp -> filename, file_name, sizeof(file_tmp -> filename));
665  file_tmp -> tree = Tree_Handle;
666  file_tmp -> fid = 0xFFFF; /* Is this an invalid FID? */
667 
668  param_len = strlen(file_name) + 2; /* 1 for null, 1 for ASCII marker */
669 
670  pkt_len = SMB_creat_len + param_len;
671 
672  pkt = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(pkt_len);
673 
674  if (pkt == NULL) { /* Really should do some error handling */
675 
676  if (File_Handle == NULL)
677  free(file_tmp);
679  return(NULL);
680 
681  }
682 
683  /* Now plug in the bits we need */
684 
685  memset(SMB_Hdr(pkt), 0, SMB_creat_len);
686  SIVAL(SMB_Hdr(pkt), SMB_hdr_idf_offset, SMB_DEF_IDF); /* Plunk in IDF */
688  SSVAL(SMB_Hdr(pkt), SMB_hdr_pid_offset, Tree_Handle -> con -> pid);
689  SSVAL(SMB_Hdr(pkt), SMB_hdr_tid_offset, Tree_Handle -> tid);
690  SSVAL(SMB_Hdr(pkt), SMB_hdr_mid_offset, Tree_Handle -> con -> mid);
691  SSVAL(SMB_Hdr(pkt), SMB_hdr_uid_offset, Tree_Handle -> con -> uid);
692  *(SMB_Hdr(pkt) + SMB_hdr_wct_offset) = 3;
693 
694  SSVAL(SMB_Hdr(pkt), SMB_creat_atr_offset, search);
697  SSVAL(SMB_Hdr(pkt), SMB_creat_bcc_offset, param_len);
698 
699  /* Now plug in the file name ... */
700 
701  p = (char *)(SMB_Hdr(pkt) + SMB_creat_buf_offset);
702  *p = SMBasciiID;
703  strcpy(p+1, file_name);
704  p = p + strlen(file_name);
705  *(p+1) = 0; /* plug in a null ... */
706 
707  /* Now send the packet and get the response ... */
708 
709  if (RFCNB_Send(Tree_Handle -> con -> Trans_Connect, pkt, pkt_len) < 0) {
710 
711 #ifdef DEBUG
712  fprintf(stderr, "Error sending Open request\n");
713 #endif
714 
715  if (File_Handle == NULL)
716  free(file_tmp);
717  RFCNB_Free_Pkt(pkt);
719  return(NULL);
720 
721  }
722 
723  /* Now get the response ... */
724 
725 #ifdef DEBUG
726  fprintf(stderr, "Pkt_Len for Create resp = %i\n", pkt_len);
727 #endif
728 
729  if (RFCNB_Recv(Tree_Handle -> con -> Trans_Connect, pkt, pkt_len) < 0) {
730 
731 #ifdef DEBUG
732  fprintf(stderr, "Error receiving response to create request\n");
733 #endif
734 
735  if (File_Handle == NULL)
736  free(file_tmp);
737  RFCNB_Free_Pkt(pkt);
739  return(NULL);
740 
741  }
742 
743  /* Now parse the response and pass back any error ... */
744 
745  if (CVAL(SMB_Hdr(pkt), SMB_hdr_rcls_offset) != SMBC_SUCCESS) { /* Process error */
746 
747 #ifdef DEBUG
748  fprintf(stderr, "SMB_Create failed with errorclass = %i, Error Code = %i\n",
751 #endif
752 
753  if (File_Handle == NULL)
754  free(file_tmp);
756  RFCNB_Free_Pkt(pkt);
758  return(NULL); /* Should clean up ... */
759 
760  }
761 
762  file_tmp -> fid = SVAL(SMB_Hdr(pkt), SMB_creatr_fid_offset);
763  file_tmp -> lastmod = 0;
764  file_tmp -> size = 0;
765  file_tmp -> access = SMB_AMODE_OPENRW;
766  file_tmp -> fileloc = 0;
767 
768  RFCNB_Free_Pkt(pkt); /* Free up this space */
769 
770 #ifdef DEBUG
771  fprintf(stderr, "SMB_Create succeeded, FID = %i\n", file_tmp -> fid);
772 #endif
773 
774  return(file_tmp);
775 
776 }
777 
778 /* Delete the file passed in as file_name. */
779 
780 int SMB_Delete(SMB_Tree_Handle tree, char *file_name, WORD search)
781 
782 {
783  struct RFCNB_Pkt *pkt;
784  int pkt_len, param_len;
785  char *p;
786 
787  param_len = strlen(file_name) + 2;
788  pkt_len = SMB_delet_len + param_len;
789 
790  pkt = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(pkt_len);
791 
792  if (pkt == NULL) { /* Really should do some error handling */
793 
795  return(SMBlibE_BAD);
796 
797  }
798 
799  /* Now plug in the bits we need */
800 
801  memset(SMB_Hdr(pkt), 0, SMB_delet_len);
802  SIVAL(SMB_Hdr(pkt), SMB_hdr_idf_offset, SMB_DEF_IDF); /* Plunk in IDF */
804  SSVAL(SMB_Hdr(pkt), SMB_hdr_pid_offset, tree -> con -> pid);
805  SSVAL(SMB_Hdr(pkt), SMB_hdr_tid_offset, tree -> tid);
806  SSVAL(SMB_Hdr(pkt), SMB_hdr_mid_offset, tree -> con -> mid);
807  SSVAL(SMB_Hdr(pkt), SMB_hdr_uid_offset, tree -> con -> uid);
808  *(SMB_Hdr(pkt) + SMB_hdr_wct_offset) = 1;
809 
810  SIVAL(SMB_Hdr(pkt), SMB_delet_sat_offset, search);
811  SSVAL(SMB_Hdr(pkt), SMB_delet_bcc_offset, param_len);
812 
813  /* Now plug in the file name ... */
814 
815  p = (char *)(SMB_Hdr(pkt) + SMB_delet_buf_offset);
816  *p = SMBasciiID;
817  strcpy(p+1, file_name);
818  p = p + strlen(file_name);
819  *(p+1) = 0; /* plug in a null ... */
820 
821  /* Now send the packet and get the response ... */
822 
823  if (RFCNB_Send(tree -> con -> Trans_Connect, pkt, pkt_len) < 0) {
824 
825 #ifdef DEBUG
826  fprintf(stderr, "Error sending Delete request\n");
827 #endif
828 
829  RFCNB_Free_Pkt(pkt);
831  return(SMBlibE_BAD);
832 
833  }
834 
835  /* Now get the response ... */
836 
837  if (RFCNB_Recv(tree -> con -> Trans_Connect, pkt, pkt_len) < 0) {
838 
839 #ifdef DEBUG
840  fprintf(stderr, "Error receiving response to delete request\n");
841 #endif
842 
843  RFCNB_Free_Pkt(pkt);
845  return(SMBlibE_BAD);
846 
847  }
848 
849  /* Now parse the response and pass back any error ... */
850 
851  if (CVAL(SMB_Hdr(pkt), SMB_hdr_rcls_offset) != SMBC_SUCCESS) { /* Process error */
852 
853 #ifdef DEBUG
854  fprintf(stderr, "SMB_Delete failed with errorclass = %i, Error Code = %i\n",
857 #endif
858 
860  RFCNB_Free_Pkt(pkt);
862  return(SMBlibE_BAD); /* Should clean up ... */
863 
864  }
865 
866 #ifdef DEBUG
867  fprintf(stderr, "File %s deleted successfully.\n", file_name);
868 #endif DEBUG
869 
870  RFCNB_Free_Pkt(pkt);
871 
872  return(0);
873 }
874 
875 /* Create the directory passed in as dir_name */
876 
877 int SMB_Create_Dir(SMB_Tree_Handle tree, char *dir_name)
878 
879 {
880  struct RFCNB_Pkt *pkt;
881  int pkt_len, param_len;
882  char *p;
883 
884  param_len = strlen(dir_name) + 2; /* + null and + asciiID */
885  pkt_len = SMB_creatdir_len + param_len;
886 
887  pkt = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(pkt_len);
888 
889  if (pkt == NULL) { /* Really should do some error handling */
890 
892  return(SMBlibE_BAD);
893 
894  }
895 
896  /* Now plug in the bits we need */
897 
898  memset(SMB_Hdr(pkt), 0, SMB_creatdir_len);
899  SIVAL(SMB_Hdr(pkt), SMB_hdr_idf_offset, SMB_DEF_IDF); /* Plunk in IDF */
900  *(SMB_Hdr(pkt) + SMB_hdr_com_offset) = SMBmkdir;
901  SSVAL(SMB_Hdr(pkt), SMB_hdr_pid_offset, tree -> con -> pid);
902  SSVAL(SMB_Hdr(pkt), SMB_hdr_tid_offset, tree -> tid);
903  SSVAL(SMB_Hdr(pkt), SMB_hdr_mid_offset, tree -> con -> mid);
904  SSVAL(SMB_Hdr(pkt), SMB_hdr_uid_offset, tree -> con -> uid);
905  *(SMB_Hdr(pkt) + SMB_hdr_wct_offset) = 0;
906 
907  SSVAL(SMB_Hdr(pkt), SMB_creatdir_bcc_offset, param_len);
908 
909  /* Now plug in the file name ... */
910 
911  p = (char *)(SMB_Hdr(pkt) + SMB_creatdir_buf_offset);
912  *p = SMBasciiID;
913  strcpy(p+1, dir_name);
914  p = p + strlen(dir_name);
915  *(p+1) = 0; /* plug in a null ... */
916 
917  /* Now send the packet and get the response ... */
918 
919  if (RFCNB_Send(tree -> con -> Trans_Connect, pkt, pkt_len) < 0) {
920 
921 #ifdef DEBUG
922  fprintf(stderr, "Error sending Create Dir request\n");
923 #endif
924 
925  RFCNB_Free_Pkt(pkt);
927  return(SMBlibE_BAD);
928 
929  }
930 
931  /* Now get the response ... */
932 
933  if (RFCNB_Recv(tree -> con -> Trans_Connect, pkt, pkt_len) < 0) {
934 
935 #ifdef DEBUG
936  fprintf(stderr, "Error receiving response to Create Dir request\n");
937 #endif
938 
939  RFCNB_Free_Pkt(pkt);
941  return(SMBlibE_BAD);
942 
943  }
944 
945  /* Now parse the response and pass back any error ... */
946 
947  if (CVAL(SMB_Hdr(pkt), SMB_hdr_rcls_offset) != SMBC_SUCCESS) { /* Process error */
948 
949 #ifdef DEBUG
950  fprintf(stderr, "SMB_Create_Dir failed with errorclass = %i, Error Code = %i\n",
953 #endif
954 
956  RFCNB_Free_Pkt(pkt);
958  return(SMBlibE_BAD); /* Should clean up ... */
959 
960  }
961 
962 #ifdef DEBUG
963  fprintf(stderr, "Directory %s created successfully.\n", dir_name);
964 #endif DEBUG
965 
966  RFCNB_Free_Pkt(pkt);
967 
968  return(0);
969 }
970 
971 /* Delete the directory passed as dir_name, as long as it is empty ... */
972 
973 int SMB_Delete_Dir(SMB_Tree_Handle tree, char *dir_name)
974 
975 {
976  struct RFCNB_Pkt *pkt;
977  int pkt_len, param_len;
978  char *p;
979 
980  param_len = strlen(dir_name) + 2; /* + null and + asciiID */
981  pkt_len = SMB_deletdir_len + param_len;
982 
983  pkt = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(pkt_len);
984 
985  if (pkt == NULL) { /* Really should do some error handling */
986 
988  return(SMBlibE_BAD);
989 
990  }
991 
992  /* Now plug in the bits we need */
993 
994  memset(SMB_Hdr(pkt), 0, SMB_deletdir_len);
995  SIVAL(SMB_Hdr(pkt), SMB_hdr_idf_offset, SMB_DEF_IDF); /* Plunk in IDF */
996  *(SMB_Hdr(pkt) + SMB_hdr_com_offset) = SMBrmdir;
997  SSVAL(SMB_Hdr(pkt), SMB_hdr_pid_offset, tree -> con -> pid);
998  SSVAL(SMB_Hdr(pkt), SMB_hdr_tid_offset, tree -> tid);
999  SSVAL(SMB_Hdr(pkt), SMB_hdr_mid_offset, tree -> con -> mid);
1000  SSVAL(SMB_Hdr(pkt), SMB_hdr_uid_offset, tree -> con -> uid);
1001  *(SMB_Hdr(pkt) + SMB_hdr_wct_offset) = 0;
1002 
1003  SSVAL(SMB_Hdr(pkt), SMB_deletdir_bcc_offset, param_len);
1004 
1005  /* Now plug in the file name ... */
1006 
1007  p = (char *)(SMB_Hdr(pkt) + SMB_deletdir_buf_offset);
1008  *p = SMBasciiID;
1009  strcpy(p+1, dir_name);
1010  p = p + strlen(dir_name);
1011  *(p+1) = 0; /* plug in a null ... */
1012 
1013  /* Now send the packet and get the response ... */
1014 
1015  if (RFCNB_Send(tree -> con -> Trans_Connect, pkt, pkt_len) < 0) {
1016 
1017 #ifdef DEBUG
1018  fprintf(stderr, "Error sending Delete Dir request\n");
1019 #endif
1020 
1021  RFCNB_Free_Pkt(pkt);
1023  return(SMBlibE_BAD);
1024 
1025  }
1026 
1027  /* Now get the response ... */
1028 
1029  if (RFCNB_Recv(tree -> con -> Trans_Connect, pkt, pkt_len) < 0) {
1030 
1031 #ifdef DEBUG
1032  fprintf(stderr, "Error receiving response to Delete Dir request\n");
1033 #endif
1034 
1035  RFCNB_Free_Pkt(pkt);
1037  return(SMBlibE_BAD);
1038 
1039  }
1040 
1041  /* Now parse the response and pass back any error ... */
1042 
1043  if (CVAL(SMB_Hdr(pkt), SMB_hdr_rcls_offset) != SMBC_SUCCESS) { /* Process error */
1044 
1045 #ifdef DEBUG
1046  fprintf(stderr, "SMB_Delete_Dir failed with errorclass = %i, Error Code = %i\n",
1049 #endif
1050 
1052  RFCNB_Free_Pkt(pkt);
1054  return(SMBlibE_BAD); /* Should clean up ... */
1055 
1056  }
1057 
1058 #ifdef DEBUG
1059  fprintf(stderr, "Directory %s deleted successfully.\n", dir_name);
1060 #endif DEBUG
1061 
1062  RFCNB_Free_Pkt(pkt);
1063 
1064  return(0);
1065 }
1066 
1067 /* Check for the existence of the directory in dir_name */
1068 
1069 int SMB_Check_Dir(SMB_Tree_Handle tree, char *dir_name)
1070 
1071 {
1072  struct RFCNB_Pkt *pkt;
1073  int pkt_len, param_len;
1074  char *p;
1075 
1076  param_len = strlen(dir_name) + 2; /* + null and + asciiID */
1077  pkt_len = SMB_checkdir_len + param_len;
1078 
1079  pkt = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(pkt_len);
1080 
1081  if (pkt == NULL) { /* Really should do some error handling */
1082 
1084  return(SMBlibE_BAD);
1085 
1086  }
1087 
1088  /* Now plug in the bits we need */
1089 
1090  memset(SMB_Hdr(pkt), 0, SMB_checkdir_len);
1091  SIVAL(SMB_Hdr(pkt), SMB_hdr_idf_offset, SMB_DEF_IDF); /* Plunk in IDF */
1092  *(SMB_Hdr(pkt) + SMB_hdr_com_offset) = SMBchkpth;
1093  SSVAL(SMB_Hdr(pkt), SMB_hdr_pid_offset, tree -> con -> pid);
1094  SSVAL(SMB_Hdr(pkt), SMB_hdr_tid_offset, tree -> tid);
1095  SSVAL(SMB_Hdr(pkt), SMB_hdr_mid_offset, tree -> con -> mid);
1096  SSVAL(SMB_Hdr(pkt), SMB_hdr_uid_offset, tree -> con -> uid);
1097  *(SMB_Hdr(pkt) + SMB_hdr_wct_offset) = 0;
1098 
1099  SSVAL(SMB_Hdr(pkt), SMB_checkdir_bcc_offset, param_len);
1100 
1101  /* Now plug in the file name ... */
1102 
1103  p = (char *)(SMB_Hdr(pkt) + SMB_checkdir_buf_offset);
1104  *p = SMBasciiID;
1105  strcpy(p+1, dir_name);
1106  p = p + strlen(dir_name);
1107  *(p+1) = 0; /* plug in a null ... */
1108 
1109  /* Now send the packet and get the response ... */
1110 
1111  if (RFCNB_Send(tree -> con -> Trans_Connect, pkt, pkt_len) < 0) {
1112 
1113 #ifdef DEBUG
1114  fprintf(stderr, "Error sending Check Dir Path request\n");
1115 #endif
1116 
1117  RFCNB_Free_Pkt(pkt);
1119  return(SMBlibE_BAD);
1120 
1121  }
1122 
1123  /* Now get the response ... */
1124 
1125  if (RFCNB_Recv(tree -> con -> Trans_Connect, pkt, pkt_len) < 0) {
1126 
1127 #ifdef DEBUG
1128  fprintf(stderr, "Error receiving response to Check Dir request\n");
1129 #endif
1130 
1131  RFCNB_Free_Pkt(pkt);
1133  return(SMBlibE_BAD);
1134 
1135  }
1136 
1137  /* Now parse the response and pass back any error ... */
1138 
1139  if (CVAL(SMB_Hdr(pkt), SMB_hdr_rcls_offset) != SMBC_SUCCESS) { /* Process error */
1140 
1141 #ifdef DEBUG
1142  fprintf(stderr, "SMB_Check_Dir failed with errorclass = %i, Error Code = %i\n",
1145 #endif
1146 
1148  RFCNB_Free_Pkt(pkt);
1150  return(SMBlibE_BAD); /* Should clean up ... */
1151 
1152  }
1153 
1154 #ifdef DEBUG
1155  fprintf(stderr, "Directory %s checked successfully.\n", dir_name);
1156 #endif DEBUG
1157 
1158  RFCNB_Free_Pkt(pkt);
1159 
1160  return(0);
1161 }
1162 
1163 /* Search directory for the files listed ... Relative to the TID in the */
1164 /* Con Handle. Return number of Dir Ents returned as the result. */
1165 
1167  char *dir_name,
1168  WORD search,
1169  SMB_CP_dirent *dirents,
1170  int direntc,
1171  char *resumekey,
1172  int resumekey_len)
1173 
1174 {
1175  struct RFCNB_Pkt *pkt, *recv_pkt;
1176  int pkt_len, param_len, recv_param_len, recv_pkt_len, ret_count, i;
1177  char *p;
1178 
1179  param_len = strlen(dir_name) + 2 + resumekey_len + 3; /* You have to know */
1180  pkt_len = SMB_search_len + param_len;
1181 
1182  recv_param_len = direntc * SMB_searchr_dirent_len + 3;
1183  recv_pkt_len = SMB_searchr_len + recv_param_len;
1184 
1185  pkt = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(pkt_len);
1186 
1187  if (pkt == NULL) { /* Really should do some error handling */
1188 
1190  return(SMBlibE_BAD);
1191 
1192  }
1193 
1194  recv_pkt = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(recv_pkt_len);
1195 
1196  if (recv_pkt == NULL) { /* Really should do some error handling */
1197 
1198  RFCNB_Free_Pkt(pkt);
1200  return(SMBlibE_BAD);
1201 
1202  }
1203 
1204  /* Now plug in the bits we need */
1205 
1206  memset(SMB_Hdr(pkt), 0, SMB_search_len);
1207  SIVAL(SMB_Hdr(pkt), SMB_hdr_idf_offset, SMB_DEF_IDF); /* Plunk in IDF */
1208  *(SMB_Hdr(pkt) + SMB_hdr_com_offset) = SMBsearch;
1209  SSVAL(SMB_Hdr(pkt), SMB_hdr_pid_offset, tree -> con -> pid);
1210  SSVAL(SMB_Hdr(pkt), SMB_hdr_tid_offset, tree -> tid);
1211  SSVAL(SMB_Hdr(pkt), SMB_hdr_mid_offset, tree -> con -> mid);
1212  SSVAL(SMB_Hdr(pkt), SMB_hdr_uid_offset, tree -> con -> uid);
1213 
1214  /* Tell server we known about non-dos names and extended attibutes */
1215 
1218 
1219  *(SMB_Hdr(pkt) + SMB_hdr_wct_offset) = 2;
1220 
1221  SSVAL(SMB_Hdr(pkt), SMB_search_mdc_offset, direntc); /* How many we want */
1222  SSVAL(SMB_Hdr(pkt), SMB_search_atr_offset, search);
1223  SSVAL(SMB_Hdr(pkt), SMB_search_bcc_offset, param_len);
1224 
1225  /* Now plug in the file name ... */
1226 
1227  p = (char *)(SMB_Hdr(pkt) + SMB_search_buf_offset);
1228  *p = SMBasciiID;
1229  strcpy(p+1, dir_name);
1230  p = p + strlen(dir_name) + 2; /* Skip the null */
1231 
1232  *p = SMBvariableblockID;
1233  p = p + 1;
1234 
1235  /* And now the resume key */
1236 
1237  SSVAL(p, 0, resumekey_len);
1238 
1239  p = p + 2;
1240 
1241  bcopy(resumekey, p, resumekey_len);
1242 
1243  /* Now send the packet and get the response ... */
1244 
1245  if (RFCNB_Send(tree -> con -> Trans_Connect, pkt, pkt_len) < 0) {
1246 
1247 #ifdef DEBUG
1248  fprintf(stderr, "Error sending search request\n");
1249 #endif
1250 
1251  RFCNB_Free_Pkt(pkt);
1252  RFCNB_Free_Pkt(recv_pkt);
1254  return(SMBlibE_BAD);
1255 
1256  }
1257 
1258  /* Now get the response ... */
1259 
1260  if (RFCNB_Recv(tree -> con -> Trans_Connect, recv_pkt, recv_pkt_len) < 0) {
1261 
1262 #ifdef DEBUG
1263  fprintf(stderr, "Error receiving response to Check Dir request\n");
1264 #endif
1265 
1266  RFCNB_Free_Pkt(pkt);
1267  RFCNB_Free_Pkt(recv_pkt);
1269  return(SMBlibE_BAD);
1270 
1271  }
1272 
1273  /* Now parse the response and pass back any error ... */
1274 
1275  if (CVAL(SMB_Hdr(recv_pkt), SMB_hdr_rcls_offset) != SMBC_SUCCESS) { /* Process error */
1276 
1277 #ifdef DEBUG
1278  fprintf(stderr, "SMB_Check_Dir failed with errorclass = %i, Error Code = %i\n",
1279  CVAL(SMB_Hdr(recv_pkt), SMB_hdr_rcls_offset),
1280  SVAL(SMB_Hdr(recv_pkt), SMB_hdr_err_offset));
1281 #endif
1282 
1284  RFCNB_Free_Pkt(pkt);
1285  RFCNB_Free_Pkt(recv_pkt);
1287  return(SMBlibE_BAD); /* Should clean up ... */
1288 
1289  }
1290 
1291  /* Now copy the results into the user's structure */
1292 
1293  ret_count = SVAL(SMB_Hdr(recv_pkt), SMB_searchr_dec_offset);
1294 
1295  p = SMB_Hdr(recv_pkt) + SMB_searchr_buf_offset + 3;
1296 
1297  /* Hmmm, should check that we have the right number of bytes ... */
1298 
1299  for (i = 0; i < ret_count; i++) {
1300 
1301  bcopy(p, dirents[i].resume_key, 21);
1302 
1303  p = p + 21;
1304 
1305  dirents[i].file_attributes = (unsigned char)*p;
1306 
1307  p = p + 1;
1308 
1309  dirents[i].date_time = IVAL(p, 0); /* Should this be IVAL? */
1310 
1311  p = p + 4;
1312 
1313  dirents[i].size = IVAL(p, 0);
1314 
1315  p = p + 4;
1316 
1317  bcopy(p, dirents[i].filename, 13); /* Copy in file name */
1318 
1319  p = p + 13;
1320 
1321  }
1322 
1323  return(ret_count);
1324 
1325 }
1326 
#define SMB_write_buf_offset
Definition: smblib-priv.h:339
#define SMBopen
Definition: smblib-priv.h:56
unsigned char file_attributes
#define SMB_AMODE_OPENRW
#define SMBC_SUCCESS
Definition: smblib-common.h:52
void RFCNB_Free_Pkt(struct RFCNB_Pkt *pkt)
Definition: rfcnb-util.c:231
int SMBlib_SMB_Error
Definition: smblib.c:36
#define SMBlibE_RecvFailed
#define SMB_write_bcc_offset
Definition: smblib-priv.h:338
#define SMB_clos_fid_offset
Definition: smblib-priv.h:327
#define SMB_searchr_dec_offset
Definition: smblib-priv.h:436
#define SMB_hdr_pid_offset
Definition: smblib-priv.h:194
#define SMB_creatr_fid_offset
Definition: smblib-priv.h:371
#define SMB_checkdir_buf_offset
Definition: smblib-priv.h:425
#define SMB_deletdir_len
Definition: smblib-priv.h:420
#define CVAL(buf, pos)
Definition: byteorder.h:49
#define SMB_open_atr_offset
Definition: smblib-priv.h:288
#define SMB_hdr_idf_offset
Definition: smblib-priv.h:177
int i
Definition: membanger.c:49
#define SMB_DEF_IDF
Definition: smblib-priv.h:50
#define SMB_search_atr_offset
Definition: smblib-priv.h:431
#define SMB_hdr_com_offset
Definition: smblib-priv.h:178
SMB_Tree_Handle tree
Definition: smblib-priv.h:533
int SMB_Create_Dir(SMB_Tree_Handle tree, char *dir_name)
Definition: file.c:877
SMB_File * SMB_Open(SMB_Tree_Handle Tree_Handle, SMB_File *File_Handle, char *file_name, WORD mode, WORD search)
Definition: file.c:44
#define SMB_search_mdc_offset
Definition: smblib-priv.h:430
#define SMB_hdr_wct_offset
Definition: smblib-priv.h:197
#define SIVAL(buf, pos, val)
Definition: byteorder.h:61
#define SMB_clos_len
Definition: smblib-priv.h:330
#define SMB_open_buf_offset
Definition: smblib-priv.h:290
#define SMB_write_ofs_offset
Definition: smblib-priv.h:336
#define SMB_hdr_flg2_offset
Definition: smblib-priv.h:186
char filename[256]
Definition: smblib-priv.h:534
#define SMB_read_len
Definition: smblib-priv.h:353
#define SMB_creat_buf_offset
Definition: smblib-priv.h:368
char * p
Definition: membanger.c:43
#define SMB_read_ofs_offset
Definition: smblib-priv.h:350
#define SMB_FLG2_NON_DOS
Definition: smblib-priv.h:141
off_t SMB_Lseek(SMB_File *File_Handle, off_t offset, int whence)
Definition: file.c:446
#define SMBclose
Definition: smblib-priv.h:58
A const & max(A const &lhs, A const &rhs)
#define SMBmkdir
Definition: smblib-priv.h:54
#define SMB_clos_bcc_offset
Definition: smblib-priv.h:329
struct RFCNB_Pkt * RFCNB_Alloc_Pkt(int n)
Definition: rfcnb-util.c:202
#define SMB_creatdir_len
Definition: smblib-priv.h:414
#define SMB_creat_atr_offset
Definition: smblib-priv.h:364
#define SMBvariableblockID
Definition: smblib-priv.h:135
#define SMB_write_clf_offset
Definition: smblib-priv.h:337
#define SMBdatablockID
Definition: smblib-priv.h:131
#define SMB_delet_buf_offset
Definition: smblib-priv.h:377
#define SMB_deletdir_bcc_offset
Definition: smblib-priv.h:418
#define SMB_creatdir_bcc_offset
Definition: smblib-priv.h:412
#define SMB_checkdir_bcc_offset
Definition: smblib-priv.h:424
void const char HLPCB void * data
Definition: stub_helper.cc:16
#define SMBcreate
Definition: smblib-priv.h:57
unsigned int size
#define SMB_hdr_flg_offset
Definition: smblib-priv.h:183
#define SMB_openr_fsz_offset
Definition: smblib-priv.h:313
int SMB_Close(SMB_File *File_Handle)
Definition: file.c:192
#define SMBrmdir
Definition: smblib-priv.h:55
#define SMB_FLG2_EXT_ATR
Definition: smblib-priv.h:142
#define SMB_openr_acc_offset
Definition: smblib-priv.h:314
#define SMB_open_len
Definition: smblib-priv.h:291
#define SMB_checkdir_len
Definition: smblib-priv.h:426
#define SMB_hdr_rcls_offset
Definition: smblib-priv.h:179
#define SVAL(buf, pos)
Definition: byteorder.h:54
#define SMB_creatdir_buf_offset
Definition: smblib-priv.h:413
#define SMBunlink
Definition: smblib-priv.h:60
#define SMB_hdr_uid_offset
Definition: smblib-priv.h:195
#define SMB_creat_tim_offset
Definition: smblib-priv.h:365
int SMBlib_errno
Definition: smblib.c:35
int SMB_Delete(SMB_Tree_Handle tree, char *file_name, WORD search)
Definition: file.c:780
#define SSVAL(buf, pos, val)
Definition: byteorder.h:60
#define SMBlibE_SendFailed
#define SMB_read_clf_offset
Definition: smblib-priv.h:351
unsigned int date_time
#define SMB_delet_len
Definition: smblib-priv.h:378
#define SMB_searchr_buf_offset
Definition: smblib-priv.h:438
int unsigned int const char *desc STUB void int len
Definition: stub_fd.cc:20
#define SMB_searchr_dirent_len
Definition: smblib-priv.h:441
#define SMB_deletdir_buf_offset
Definition: smblib-priv.h:419
#define SMB_openr_tim_offset
Definition: smblib-priv.h:312
static pid_t pid
Definition: IcmpSquid.cc:35
#define SMB_search_len
Definition: smblib-priv.h:434
int RFCNB_Send(struct RFCNB_Con *Con_Handle, struct RFCNB_Pkt *udata, int Length)
Definition: session.c:183
unsigned short WORD
Definition: smblib-priv.h:145
struct RFCNB_Pkt * next
Definition: rfcnb-common.h:46
int RFCNB_Recv(void *Con_Handle, struct RFCNB_Pkt *Data, int Length)
Definition: session.c:235
#define SMB_read_fid_offset
Definition: smblib-priv.h:348
#define SMB_clos_tim_offset
Definition: smblib-priv.h:328
#define SMB_readr_cnt_offset
Definition: smblib-priv.h:355
#define SMB_open_bcc_offset
Definition: smblib-priv.h:289
int SMB_Check_Dir(SMB_Tree_Handle tree, char *dir_name)
Definition: file.c:1069
#define SMB_hdr_mid_offset
Definition: smblib-priv.h:196
int SMB_Read(SMB_File *File_Handle, char *data, int numbytes)
Definition: file.c:297
#define SMB_creat_len
Definition: smblib-priv.h:369
int SMB_Search(SMB_Tree_Handle tree, char *dir_name, WORD search, SMB_CP_dirent *dirents, int direntc, char *resumekey, int resumekey_len)
Definition: file.c:1166
#define SMB_write_cnt_offset
Definition: smblib-priv.h:335
#define SMBchkpth
Definition: smblib-priv.h:70
SMB_File * SMB_Create(SMB_Tree_Handle Tree_Handle, SMB_File *File_Handle, char *file_name, WORD search)
Definition: file.c:634
#define SMBwrite
Definition: smblib-priv.h:65
#define SMBasciiID
Definition: smblib-priv.h:134
#define SMB_hdr_tid_offset
Definition: smblib-priv.h:193
#define SMB_searchr_len
Definition: smblib-priv.h:439
#define SMB_creat_dat_offset
Definition: smblib-priv.h:366
int SMB_Write(SMB_File *File_Handle, char *data, int numbytes)
Definition: file.c:481
#define SMB_delet_bcc_offset
Definition: smblib-priv.h:376
#define SMBlibE_NoSpace
#define SMB_readr_len
Definition: smblib-priv.h:360
#define SMBlibE_BAD
#define SMB_read_cnt_offset
Definition: smblib-priv.h:349
#define SMBread
Definition: smblib-priv.h:64
#define SMB_Hdr(p)
Definition: smblib-priv.h:163
#define SMBlibE_Remote
#define SMB_search_buf_offset
Definition: smblib-priv.h:433
#define SMBsearch
Definition: smblib-priv.h:77
#define SMB_read_bcc_offset
Definition: smblib-priv.h:352
#define SMB_creat_bcc_offset
Definition: smblib-priv.h:367
#define SMB_write_fid_offset
Definition: smblib-priv.h:334
#define IVAL(buf, pos)
Definition: byteorder.h:55
#define SMB_openr_len
Definition: smblib-priv.h:316
#define SMB_search_bcc_offset
Definition: smblib-priv.h:432
#define SMB_delet_sat_offset
Definition: smblib-priv.h:375
int SMB_Delete_Dir(SMB_Tree_Handle tree, char *dir_name)
Definition: file.c:973
#define SMB_open_mod_offset
Definition: smblib-priv.h:287
#define NULL
Definition: types.h:166
#define SMB_write_len
Definition: smblib-priv.h:340
int size
Definition: ModDevPoll.cc:77
#define SMB_hdr_err_offset
Definition: smblib-priv.h:181
#define SMB_openr_fid_offset
Definition: smblib-priv.h:310
#define free(a)
Definition: hash.c:31

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors