workbench/network/smbfs/source_code/main.c

   1 /*
   2  * $Id$
   3  *
   4  * :ts=4
   5  *
   6  * SMB file system wrapper for AmigaOS, using the AmiTCP V3 API
   7  *
   8  * Copyright (C) 2000-2009 by Olaf `Olsen' Barthel <obarthel -at- gmx -dot- net>
   9  * Copyright (C) 2011-2014, The AROS Development Team
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 #include "smbfs.h"
  27
  28 /****************************************************************************/
  29
  30 #include "smb_abstraction.h"
  31
  32 /****************************************************************************/
  33
  34 #include <smb/smb.h>
  35
  36 /****************************************************************************/
  37
  38 #if defined(__amigaos4__) && !defined(Flush)
  39 #define Flush(fh) FFlush(fh)
  40 #endif /* __amigaos4__ && !Flush */
  41
  42 /****************************************************************************/
  43
  44 /* A quick workaround for the timeval/timerequest->TimeVal/TimeRequest
  45    change in the recent OS4 header files. */
  46 #if defined(__NEW_TIMEVAL_DEFINITION_USED__)
  47
  48 #define timeval         TimeVal
  49 #define tv_secs         Seconds
  50 #define tv_micro        Microseconds
  51
  52 #define timerequest     TimeRequest
  53 #define tr_node         Request
  54 #define tr_time         Time
  55
  56 #endif /* __NEW_TIMEVAL_DEFINITION_USED__ */
  57
  58 /****************************************************************************/
  59
  60 /* This is for backwards compatibility only. */
  61 #if defined(__amigaos4__)
  62 #define fib_EntryType fib_Obsolete
  63 #endif /* __amigaos4__ */
  64
  65 /****************************************************************************/
  66
  67 #if !defined(__AROS__)
  68 #include "smbfs_rev.h"
  69 STRPTR Version = VERSTAG;
  70 #endif /* __AROS__ */
  71
  72 CONST TEXT HandlerName[] = "smb-handler";
  73
  74 /****************************************************************************/
  75
  76 #define UNIX_TIME_OFFSET 252460800
  77 #define MAX_FILENAME_LEN 256
  78
  79 /****************************************************************************/
  80
  81 #define SMB_ROOT_DIR_NAME       "\\"
  82 #define SMB_PATH_SEPARATOR      '\\'
  83
  84 /****************************************************************************/
  85
  86 typedef STRPTR  KEY;
  87 typedef LONG *  NUMBER;
  88 typedef LONG    SWITCH;
  89
  90 /****************************************************************************/
  91
  92 struct FileNode
  93 {
  94         struct MinNode          fn_MinNode;
  95         struct FileHandle *     fn_Handle;
  96         LONG                            fn_Offset;
  97         LONG                            fn_Mode;
  98         smba_file_t *           fn_File;
  99         STRPTR                          fn_FullName;
 100 };
 101
 102 struct LockNode
 103 {
 104         struct MinNode  ln_MinNode;
 105         struct FileLock ln_FileLock;
 106         smba_file_t *   ln_File;
 107         BOOL                    ln_RestartExamine;
 108         UWORD                   ln_Pad;
 109         STRPTR                  ln_FullName;
 110 };
 111
 112 /****************************************************************************/
 113
 114 /* The minimum operating system version we require to work. */
 115 #define MINIMUM_OS_VERSION 37           /* Kickstart 2.04 or better */
 116 /*#define MINIMUM_OS_VERSION 39*/       /* Kickstart 3.0 or better */
 117
 118 /****************************************************************************/
 119
 120 /* Careful: the memory pool routines in amiga.lib are available only to
 121  *          SAS/C and similar compilers (not necessarily to GCC).
 122  */
 123 #if defined(__GNUC__) && (MINIMUM_OS_VERSION < 39)
 124
 125 #undef MINIMUM_OS_VERSION
 126 #define MINIMUM_OS_VERSION 39
 127
 128 #endif /* __GNUC__ */
 129
 130 /****************************************************************************/
 131
 132 #if (MINIMUM_OS_VERSION < 39)
 133
 134 /* These are in amiga.lib */
 135 APTR ASM AsmCreatePool(REG(d0,ULONG memFlags),REG(d1,ULONG puddleSize),REG(d2,ULONG threshSize),REG(a6,struct Library * SysBase));
 136 VOID ASM AsmDeletePool(REG(a0,APTR poolHeader),REG(a6,struct Library * SysBase));
 137 APTR ASM AsmAllocPooled(REG(a0,APTR poolHeader),REG(d0,ULONG memSize),REG(a6,struct Library * SysBase));
 138 VOID ASM AsmFreePooled(REG(a0,APTR poolHeader),REG(a1,APTR memory),REG(d0,ULONG memSize),REG(a6,struct Library * SysBase));
 139
 140 #define CreatePool(memFlags,puddleSize,threshSize) AsmCreatePool((memFlags),(puddleSize),(threshSize),SysBase)
 141 #define DeletePool(poolHeader) AsmDeletePool((poolHeader),SysBase)
 142 #define AllocPooled(poolHeader,memSize) AsmAllocPooled((poolHeader),(memSize),SysBase)
 143 #define FreePooled(poolHeader,memory,memSize) AsmFreePooled((poolHeader),(memory),(memSize),SysBase)
 144
 145 #endif /* MINIMUM_OS_VERSION */
 146
 147 /****************************************************************************/
 148
 149 /* Forward declarations for local routines. */
 150 LONG _start(VOID);
 151 LONG VARARGS68K LocalPrintf(STRPTR format, ...);
 152 STRPTR amitcp_strerror(int error);
 153 STRPTR host_strerror(int error);
 154 LONG CompareNames(STRPTR a, STRPTR b);
 155 VOID StringToUpper(STRPTR s);
 156 #ifndef __AROS__
 157 VOID VARARGS68K ReportError(STRPTR fmt, ...);
 158 #endif
 159 VOID FreeMemory(APTR address);
 160 APTR AllocateMemory(ULONG size);
 161 LONG GetTimeZoneDelta(VOID);
 162 ULONG GetCurrentTime(VOID);
 163 VOID GMTime(time_t seconds, struct tm *tm);
 164 time_t MakeTime(const struct tm *const tm);
 165 #ifndef __AROS__
 166 VOID VARARGS68K SPrintf(STRPTR buffer, STRPTR formatString, ...);
 167 #endif
 168 int BroadcastNameQuery(char *name, char *scope, UBYTE *address);
 169
 170 /****************************************************************************/
 171
 172 INLINE STATIC BOOL ReallyRemoveDosEntry(struct DosList *entry);
 173 INLINE STATIC LONG BuildFullName(STRPTR parent_name, STRPTR name, STRPTR *result_ptr, LONG *result_size_ptr);
 174 INLINE STATIC VOID TranslateCName(UBYTE *name, UBYTE *map);
 175 INLINE STATIC VOID ConvertCString(LONG max_len, APTR bstring, STRPTR cstring);
 176 STATIC VOID DisplayErrorList(VOID);
 177 STATIC VOID SendDiskChange(ULONG class);
 178 STATIC struct FileNode *FindFileNode(STRPTR name, struct FileNode *skip);
 179 STATIC struct LockNode *FindLockNode(STRPTR name, struct LockNode *skip);
 180 STATIC LONG CheckAccessModeCollision(STRPTR name, LONG mode);
 181 STATIC LONG NameAlreadyInUse(STRPTR name);
 182 STATIC BOOL IsReservedName(STRPTR name);
 183 STATIC LONG MapErrnoToIoErr(int error);
 184 STATIC VOID TranslateBName(UBYTE *name, UBYTE *map);
 185 STATIC VOID Cleanup(VOID);
 186 STATIC BOOL Setup(STRPTR opt_password, BOOL opt_changecase, LONG *opt_time_zone_offset, LONG *opt_dst_offset, STRPTR translation_file);
 187 STATIC BOOL AddVolume(STRPTR service, STRPTR workgroup, STRPTR username, STRPTR opt_password, STRPTR opt_clientname, STRPTR opt_servername, int opt_cachesize, STRPTR device_name, STRPTR volume_name);
 188 STATIC VOID ConvertBString(LONG max_len, STRPTR cstring, APTR bstring);
 189 STATIC BOOL Action_Startup(struct FileSysStartupMsg *fssm, struct DosList *device_node, SIPTR *error_ptr);
 190 STATIC BPTR Action_Parent(struct FileLock *parent, SIPTR *error_ptr);
 191 STATIC LONG Action_DeleteObject(struct FileLock *parent, APTR bcpl_name, SIPTR *error_ptr);
 192 STATIC BPTR Action_CreateDir(struct FileLock *parent, APTR bcpl_name, SIPTR *error_ptr);
 193 STATIC BPTR Action_LocateObject(struct FileLock *parent, APTR bcpl_name, LONG mode, SIPTR *error_ptr);
 194 STATIC BPTR Action_CopyDir(struct FileLock *lock, SIPTR *error_ptr);
 195 STATIC LONG Action_FreeLock(struct FileLock *lock, SIPTR *error_ptr);
 196 STATIC LONG Action_SameLock(struct FileLock *lock1, struct FileLock *lock2, SIPTR *error_ptr);
 197 STATIC LONG Action_SetProtect(struct FileLock *parent, APTR bcpl_name, LONG mask, SIPTR *error_ptr);
 198 STATIC LONG Action_RenameObject(struct FileLock *source_lock, APTR source_bcpl_name, struct FileLock *destination_lock, APTR destination_bcpl_name, SIPTR *error_ptr);
 199 STATIC LONG Action_DiskInfo(struct InfoData *id, SIPTR *error_ptr);
 200 STATIC LONG Action_Info(struct FileLock *lock, struct InfoData *id, SIPTR *error_ptr);
 201 STATIC LONG Action_ExamineObject(struct FileLock *lock, struct FileInfoBlock *fib, SIPTR *error_ptr);
 202 STATIC BOOL NameIsAcceptable(STRPTR name, LONG max_len);
 203 STATIC LONG Action_ExamineNext(struct FileLock *lock, struct FileInfoBlock *fib, SIPTR *error_ptr);
 204 STATIC LONG Action_ExamineAll(struct FileLock *lock, struct ExAllData *ed, ULONG size, ULONG type, struct ExAllControl *eac, SIPTR *error_ptr);
 205 STATIC LONG Action_Find(LONG action, struct FileHandle *fh, struct FileLock *parent, APTR bcpl_name, SIPTR *error_ptr);
 206 STATIC LONG Action_Read(struct FileNode *fn, APTR mem, LONG length, SIPTR *error_ptr);
 207 STATIC LONG Action_Write(struct FileNode *fn, APTR mem, LONG length, SIPTR *error_ptr);
 208 STATIC LONG Action_End(struct FileNode *fn, SIPTR *error_ptr);
 209 STATIC LONG Action_Seek(struct FileNode *fn, LONG position, LONG mode, SIPTR *error_ptr);
 210 STATIC LONG Action_SetFileSize(struct FileNode *fn, LONG position, LONG mode, SIPTR *error_ptr);
 211 STATIC LONG Action_SetDate(struct FileLock *parent, APTR bcpl_name, struct DateStamp *ds, SIPTR *error_ptr);
 212 STATIC LONG Action_ExamineFH(struct FileNode *fn, struct FileInfoBlock *fib, SIPTR *error_ptr);
 213 STATIC BPTR Action_ParentFH(struct FileNode *fn, SIPTR *error_ptr);
 214 STATIC BPTR Action_CopyDirFH(struct FileNode *fn, SIPTR *error_ptr);
 215 STATIC LONG Action_FHFromLock(struct FileHandle *fh, struct FileLock *fl, SIPTR *error_ptr);
 216 STATIC LONG Action_RenameDisk(APTR bcpl_name, SIPTR *error_ptr);
 217 STATIC LONG Action_ChangeMode(LONG type, APTR object, LONG new_mode, SIPTR *error_ptr);
 218 STATIC LONG Action_WriteProtect(LONG flag, ULONG key, SIPTR *error_ptr);
 219 STATIC LONG Action_MoreCache(LONG buffer_delta, SIPTR *error_ptr);
 220 STATIC LONG Action_SetComment(struct FileLock *parent, APTR bcpl_name, APTR bcpl_comment, SIPTR *error_ptr);
 221 STATIC LONG Action_LockRecord(struct FileNode *fn, LONG offset, LONG length, LONG mode, ULONG timeout, SIPTR *error_ptr);
 222 STATIC LONG Action_FreeRecord(struct FileNode *fn, LONG offset, LONG length, SIPTR *error_ptr);
 223 STATIC VOID StartReconnectTimer(VOID);
 224 STATIC VOID HandleFileSystem(VOID);
 225
 226 /****************************************************************************/
 227
 228 #if !defined(__AROS__)
 229 struct Library *                        SysBase;
 230 #endif
 231 struct Library *                        DOSBase;
 232 struct Library *                        UtilityBase;
 233 struct Library *                        IntuitionBase;
 234 struct Library *                        SocketBase;
 235 struct Library *                        LocaleBase;
 236 struct Library *                        TimerBase;
 237 struct Library *                        IconBase;
 238
 239 /****************************************************************************/
 240
 241 #if defined(__amigaos4__)
 242
 243 /****************************************************************************/
 244
 245 struct ExecIFace *                      IExec;
 246 struct DOSIFace *                       IDOS;
 247 struct UtilityIFace *           IUtility;
 248 struct IntuitionIFace *         IIntuition;
 249 struct SocketIFace *            ISocket;
 250 struct LocaleIFace *            ILocale;
 251 struct TimerIFace *                     ITimer;
 252 struct IconIFace *                      IIcon;
 253
 254 /****************************************************************************/
 255
 256 #endif /* __amigaos4__ */
 257
 258 /****************************************************************************/
 259
 260 STATIC struct timerequest       TimerRequest;
 261 STATIC BOOL                                     TimerActive;
 262
 263 /****************************************************************************/
 264
 265 struct Locale *                         Locale;
 266
 267 /****************************************************************************/
 268
 269 #if !defined(__AROS__)
 270 int                                                     errno;
 271 #endif
 272 #ifndef h_errno
 273 int                                                     h_errno;
 274 #endif
 275
 276 /****************************************************************************/
 277
 278 STATIC struct DosList *         DeviceNode;
 279 STATIC struct DosList *         VolumeNode;
 280 STATIC BOOL                                     VolumeNodeAdded;
 281 STATIC struct MsgPort *         FileSystemPort;
 282
 283 STATIC smba_server_t *          ServerData;
 284
 285 STATIC BOOL                                     Quit;
 286 STATIC BOOL                                     Quiet;
 287 STATIC BOOL                                     CaseSensitive;
 288 STATIC BOOL                                     OmitHidden;
 289
 290 STATIC LONG                                     DSTOffset;
 291 STATIC LONG                                     TimeZoneOffset;
 292 STATIC BOOL                                     OverrideLocaleTimeZone;
 293
 294 STATIC BOOL                                     WriteProtected;
 295 STATIC ULONG                            WriteProtectKey;
 296
 297 STATIC struct MinList           FileList;
 298 STATIC struct MinList           LockList;
 299
 300 STATIC APTR                                     MemoryPool;
 301
 302 STATIC struct RDArgs *          Parameters;
 303 STATIC struct DiskObject *      Icon;
 304
 305 STATIC struct WBStartup *       WBStartup;
 306
 307 STATIC struct MinList           ErrorList;
 308
 309 STATIC BOOL                                     TranslateNames;
 310 STATIC UBYTE                            A2M[256];
 311 STATIC UBYTE                            M2A[256];
 312
 313 struct
 314 {
 315         KEY             Workgroup;
 316         KEY             UserName;
 317         KEY             Password;
 318         SWITCH  ChangeCase;
 319         SWITCH  CaseSensitive;
 320         SWITCH  OmitHidden;
 321         SWITCH  Quiet;
 322         KEY             ClientName;
 323         KEY             ServerName;
 324         KEY             DeviceName;
 325         KEY             VolumeName;
 326         NUMBER  CacheSize;
 327         NUMBER  DebugLevel;
 328         NUMBER  TimeZoneOffset;
 329         NUMBER  DSTOffset;
 330         KEY             TranslationFile;
 331         KEY             Service;
 332 } args;
 333
 334 CONST TEXT control_template[] =
 335         "DOMAIN=WORKGROUP/K,"
 336         "USER=USERNAME/K,"
 337         "PASSWORD/K,"
 338         "CHANGECASE/S,"
 339         "CASE=CASESENSITIVE/S,"
 340         "OMITHIDDEN/S,"
 341         "QUIET/S,"
 342         "CLIENT=CLIENTNAME/K,"
 343         "SERVER=SERVERNAME/K,"
 344         "DEVICE=DEVICENAME/K,"
 345         "VOLUME=VOLUMENAME/K,"
 346         "CACHE=CACHESIZE/N/K,"
 347         "DEBUGLEVEL=DEBUG/N/K,"
 348         "TZ=TIMEZONEOFFSET/N/K,"
 349         "DST=DSTOFFSET/N/K,"
 350         "TRANSLATE=TRANSLATIONFILE/K,"
 351         "SERVICE/A";
 352
 353 /****************************************************************************/
 354
 355 LONG _start(VOID)
 356 {
 357         LONG result = RETURN_OK;
 358
 359 #if !defined(__AROS__)
 360         SysBase = (struct Library *)AbsExecBase;
 361
 362         #if defined(__amigaos4__)
 363         {
 364                 IExec = (struct ExecIFace *)((struct ExecBase *)SysBase)->MainInterface;
 365         }
 366         #endif /* __amigaos4__ */
 367 #endif
 368
 369         FileSystemPort = &((*(struct Process *)FindTask(NULL)).pr_MsgPort);
 370
 371         /* Don't emit any debugging output before we are ready. */
 372         SETDEBUGLEVEL(0);
 373
 374         /* Open the libraries we need and check
 375          * whether we could get them.
 376          */
 377         DOSBase = OpenLibrary("dos.library",0);
 378
 379         #if defined(__amigaos4__)
 380         {
 381                 if(DOSBase != NULL)
 382                 {
 383                         IDOS = (struct DOSIFace *)GetInterface(DOSBase, "main", 1, 0);
 384                         if(IDOS == NULL)
 385                         {
 386                                 CloseLibrary(DOSBase);
 387                                 DOSBase = NULL;
 388                         }
 389                 }
 390         }
 391         #endif /* __amigaos4__ */
 392
 393         UtilityBase = OpenLibrary("utility.library",37);
 394
 395         #if defined(__amigaos4__)
 396         {
 397                 if(UtilityBase != NULL)
 398                 {
 399                         IUtility = (struct UtilityIFace *)GetInterface(UtilityBase, "main", 1, 0);
 400                         if(IUtility == NULL)
 401                         {
 402                                 CloseLibrary(UtilityBase);
 403                                 UtilityBase = NULL;
 404                         }
 405                 }
 406         }
 407         #endif /* __amigaos4__ */
 408
 409         if(UtilityBase == NULL || DOSBase == NULL || DOSBase->lib_Version < MINIMUM_OS_VERSION)
 410                 goto out;
 411
 412         /* This needs to be set up properly for ReportError()
 413          * to work.
 414          */
 415         NewList((struct List *)&ErrorList);
 416
 417                 if(Locale != NULL)
 418                         SHOWVALUE(Locale->loc_GMTOffset);
 419
 420         HandleFileSystem();
 421
 422  out:
 423
 424         Cleanup();
 425
 426         return(result);
 427 }
 428
 429 /****************************************************************************/
 430
 431 #ifdef __AROS__
 432 #define LocalPrintf(format,args...) Printf(format ,##args )
 433 #else
 434 LONG VARARGS68K
 435 LocalPrintf(STRPTR format, ...)
 436 {
 437         va_list args;
 438         LONG result;
 439
 440         #if defined(__amigaos4__)
 441         {
 442                 va_startlinear(args,format);
 443                 result = VPrintf(format,va_getlinearva(args,APTR));
 444                 va_end(args);
 445         }
 446         #else
 447         {
 448                 va_start(args,format);
 449                 result = VPrintf(format,args);
 450                 va_end(args);
 451         }
 452         #endif /* __amigaos4__ */
 453
 454         return(result);
 455 }
 456 #endif /* __AROS__ */
 457
 458 /****************************************************************************/
 459
 460 /* Obtain the descriptive text corresponding to an error number
 461  * that may have been generated by the TCP/IP stack.
 462  */
 463 STRPTR
 464 amitcp_strerror(int error)
 465 {
 466         struct TagItem tags[2];
 467         STRPTR result;
 468
 469         ENTER();
 470
 471         tags[0].ti_Tag  = SBTM_GETVAL(SBTC_ERRNOSTRPTR);
 472         tags[0].ti_Data = error;
 473         tags[1].ti_Tag  = TAG_END;
 474
 475         SocketBaseTagList(tags);
 476
 477         result = (STRPTR)tags[0].ti_Data;
 478
 479         RETURN(result);
 480         return(result);
 481 }
 482
 483 /****************************************************************************/
 484
 485 /* Return the descriptive text associated with a host lookup failure code. */
 486 STRPTR
 487 host_strerror(int error)
 488 {
 489         struct TagItem tags[2];
 490         STRPTR result;
 491
 492         ENTER();
 493
 494         tags[0].ti_Tag  = SBTM_GETVAL(SBTC_HERRNOSTRPTR);
 495         tags[0].ti_Data = error;
 496         tags[1].ti_Tag  = TAG_END;
 497
 498         SocketBaseTagList(tags);
 499
 500         result = (STRPTR)tags[0].ti_Data;
 501
 502         RETURN(result);
 503         return(result);
 504 }
 505
 506 /****************************************************************************/
 507
 508 /* Compare two strings, either case sensitive or not
 509  * sensitive to the case of the letters. How this is
 510  * to be done is controlled by a global option. This
 511  * routine is called whenever two SMB file names are
 512  * to be compared.
 513  */
 514 LONG
 515 CompareNames(STRPTR a,STRPTR b)
 516 {
 517         LONG result;
 518
 519         if(CaseSensitive)
 520                 result = strcmp(a,b);
 521         else
 522                 result = Stricmp(a,b);
 523
 524         return(result);
 525 }
 526
 527 /****************************************************************************/
 528
 529 /* Translate a string into all upper case characters. */
 530 VOID
 531 StringToUpper(STRPTR s)
 532 {
 533         UBYTE c;
 534
 535         while((c = (*s)) != '\0')
 536                 (*s++) = ToUpper(c);
 537 }
 538
 539 /****************************************************************************/
 540
 541 /* Prepare the accumulated list of error messages for display
 542  * and purge the contents of that list.
 543  */
 544 STATIC VOID
 545 DisplayErrorList(VOID)
 546 {
 547         struct MinNode * last = NULL;
 548         struct MinNode * mn;
 549         STRPTR str = NULL;
 550         STRPTR msg;
 551         LONG len;
 552
 553         /* Determine how much memory will have to be
 554          * allocated to hold all the accumulated
 555          * error messages.
 556          */
 557         len = 0;
 558
 559         for(mn = ErrorList.mlh_Head ;
 560             mn->mln_Succ != NULL ;
 561             mn = mn->mln_Succ)
 562         {
 563                 last = mn;
 564
 565                 msg = (STRPTR)(mn + 1);
 566
 567                 len += strlen(msg)+1;
 568         }
 569
 570         /* Allocate the memory for the messages, then
 571          * copy them there.
 572          */
 573         if(len > 0)
 574         {
 575                 str = AllocVec(len,MEMF_ANY);
 576                 if(str != NULL)
 577                 {
 578                         str[0] = '\0';
 579
 580                         for(mn = ErrorList.mlh_Head ;
 581                             mn->mln_Succ != NULL ;
 582                             mn = mn->mln_Succ)
 583                         {
 584                                 msg = (STRPTR)(mn + 1);
 585
 586                                 strcat(str,msg);
 587                                 if(mn != last)
 588                                         strcat(str,"\n");
 589                         }
 590                 }
 591         }
 592
 593         /* Purge the list. */
 594         while((mn = (struct MinNode *)RemHead((struct List *)&ErrorList)) != NULL)
 595                 FreeVec(mn);
 596
 597         /* Display the error messages. */
 598         if(str != NULL)
 599         {
 600                 IntuitionBase = OpenLibrary("intuition.library",37);
 601
 602                 #if defined(__amigaos4__)
 603                 {
 604                         if(IntuitionBase != NULL)
 605                         {
 606                                 IIntuition = (struct IntuitionIFace *)GetInterface(IntuitionBase, "main", 1, 0);
 607                                 if(IIntuition == NULL)
 608                                 {
 609                                         CloseLibrary(IntuitionBase);
 610                                         IntuitionBase = NULL;
 611                                 }
 612                         }
 613                 }
 614                 #endif /* __amigaos4__ */
 615
 616                 if(IntuitionBase != NULL)
 617                 {
 618                         struct EasyStruct es;
 619
 620                         memset(&es,0,sizeof(es));
 621
 622                         es.es_StructSize        = sizeof(es);
 623                         es.es_Title                     = "SMB";
 624                         es.es_TextFormat        = str;
 625                         es.es_GadgetFormat      = "Ok";
 626
 627                         EasyRequestArgs(NULL,&es,NULL,NULL);
 628                 }
 629
 630                 FreeVec(str);
 631         }
 632
 633         #if defined(__amigaos4__)
 634         {
 635                 if(IIntuition != NULL)
 636                 {
 637                         DropInterface((struct Interface *)IIntuition);
 638                         IIntuition = NULL;
 639                 }
 640         }
 641         #endif /* __amigaos4__ */
 642
 643         CloseLibrary(IntuitionBase);
 644         IntuitionBase = NULL;
 645 }
 646
 647 /****************************************************************************/
 648
 649 /* Release memory allocated from the global pool. */
 650 VOID
 651 FreeMemory(APTR address)
 652 {
 653         if(address != NULL)
 654         {
 655                 ULONG * mem = address;
 656
 657                 #if DEBUG
 658                 {
 659                         if(GETDEBUGLEVEL() > 0)
 660                                 memset(address,0xA3,mem[-1] - sizeof(*mem));
 661                 }
 662                 #endif /* DEBUG */
 663
 664                 FreePooled(MemoryPool,&mem[-1],mem[-1]);
 665         }
 666 }
 667
 668 /* Allocate memory from the global pool. */
 669 APTR
 670 AllocateMemory(ULONG size)
 671 {
 672         APTR result = NULL;
 673
 674         if(size > 0)
 675         {
 676                 ULONG * mem;
 677
 678                 size = (sizeof(*mem) + size + 7) & ~7UL;
 679
 680                 mem = AllocPooled(MemoryPool,size);
 681                 if(mem != NULL)
 682                 {
 683                         (*mem++) = size;
 684
 685                         #if DEBUG
 686                         {
 687                                 if(GETDEBUGLEVEL() > 0)
 688                                         memset(mem,0xA5,mem[-1] - sizeof(*mem));
 689                         }
 690                         #endif /* DEBUG */
 691
 692                         result = mem;
 693                 }
 694         }
 695
 696         return(result);
 697 }
 698
 699 /****************************************************************************/
 700
 701 /* Obtain the number of seconds to add to the current time
 702  * to translate local time into UTC.
 703  */
 704 LONG
 705 GetTimeZoneDelta(VOID)
 706 {
 707         LONG seconds;
 708
 709         if(OverrideLocaleTimeZone)
 710         {
 711                 seconds = 60 * TimeZoneOffset;
 712         }
 713         else if (Locale != NULL)
 714         {
 715                 /* The GMT offset actually is the number of minutes to add to
 716                  * the local time to yield Greenwich Mean Time. It is negative
 717                  * for all time zones east of the Greenwich meridian and
 718                  * positive for all time zones west of it.
 719                  */
 720                 seconds = 60 * Locale->loc_GMTOffset;
 721         }
 722         else
 723         {
 724                 seconds = 0;
 725         }
 726
 727         return(seconds + DSTOffset);
 728 }
 729
 730 /****************************************************************************/
 731
 732 /* Obtain the current time, in standard Unix format, adjusted for the
 733  * local time zone.
 734  */
 735 ULONG
 736 GetCurrentTime(VOID)
 737 {
 738         struct timeval tv;
 739         ULONG result;
 740
 741         GetSysTime((APTR)&tv);
 742
 743         result = UNIX_TIME_OFFSET + GetTimeZoneDelta() + tv.tv_secs;
 744
 745         return(result);
 746 }
 747
 748 /****************************************************************************/
 749
 750 /* Fill in a 'tm' type time specification with time information
 751  * corresponding to the number of seconds provided. Input is
 752  * in Unix format.
 753  */
 754 VOID
 755 GMTime(time_t seconds,struct tm * tm)
 756 {
 757         struct ClockData clock_data;
 758
 759         if(seconds < UNIX_TIME_OFFSET)
 760                 seconds = 0;
 761         else
 762                 seconds -= UNIX_TIME_OFFSET;
 763
 764         Amiga2Date(seconds,&clock_data);
 765
 766         memset(tm,0,sizeof(*tm));
 767
 768         tm->tm_sec      = clock_data.sec;
 769         tm->tm_min      = clock_data.min;
 770         tm->tm_hour     = clock_data.hour;
 771         tm->tm_mday     = clock_data.mday;
 772         tm->tm_mon      = clock_data.month - 1;
 773         tm->tm_year     = clock_data.year - 1900;
 774 }
 775
 776 /* Calculate the number of seconds that have passed since January 1st 1970
 777  * based upon the time specification provided. Output is in Unix format.
 778  */
 779 time_t
 780 MakeTime(const struct tm * const tm)
 781 {
 782         struct ClockData clock_data;
 783         time_t seconds;
 784
 785         clock_data.sec          = tm->tm_sec;
 786         clock_data.min          = tm->tm_min;
 787         clock_data.hour         = tm->tm_hour;
 788         clock_data.mday         = tm->tm_mday;
 789         clock_data.month        = tm->tm_mon + 1;
 790         clock_data.year         = tm->tm_year + 1900;
 791
 792         seconds = Date2Amiga(&clock_data) + UNIX_TIME_OFFSET;
 793
 794         return(seconds);
 795 }
 796
 797 /****************************************************************************/
 798
 799 /* NetBIOS broadcast name query code courtesy of Christopher R. Hertel.
 800  * Thanks much, Chris!
 801  */
 802 struct addr_entry
 803 {
 804         unsigned short flags;
 805         unsigned char address[4];
 806 };
 807
 808 struct nmb_header
 809 {
 810         unsigned short name_trn_id;
 811         unsigned short flags;
 812         unsigned short qdcount;
 813         unsigned short ancount;
 814         unsigned short nscount;
 815         unsigned short arcount;
 816 };
 817
 818 static UBYTE *
 819 L1_Encode(UBYTE * dst, const UBYTE * name, const UBYTE pad, const UBYTE sfx)
 820 {
 821         int i = 0;
 822         int j = 0;
 823         int k;
 824
 825         while(('\0' != name[i]) && (i < 15))
 826         {
 827                 k = ToUpper(name[i]);
 828                 i++;
 829                 dst[j++] = 'A' + ((k & 0xF0) >> 4);
 830                 dst[j++] = 'A' + (k & 0x0F);
 831         }
 832
 833         i = 'A' + ((pad & 0xF0) >> 4);
 834         k = 'A' + (pad & 0x0F);
 835
 836         while(j < 30)
 837         {
 838                 dst[j++] = i;
 839                 dst[j++] = k;
 840         }
 841
 842         dst[30] = 'A' + ((sfx & 0xF0) >> 4);
 843         dst[31] = 'A' + (sfx & 0x0F);
 844         dst[32] = '\0';
 845
 846         return(dst);
 847 }
 848
 849 static int
 850 L2_Encode(UBYTE * dst, const UBYTE * name, const UBYTE pad, const UBYTE sfx, const UBYTE * scope)
 851 {
 852         int lenpos;
 853         int i;
 854         int j;
 855
 856         if(NULL == L1_Encode(&dst[1], name, pad, sfx))
 857                 return(-1);
 858
 859         dst[0] = 0x20;
 860         lenpos = 33;
 861
 862         if('\0' != (*scope))
 863         {
 864                 do
 865                 {
 866                         for(i = 0, j = (lenpos + 1);
 867                             ('.' != scope[i]) && ('\0' != scope[i]);
 868                             i++, j++)
 869                         {
 870                                 dst[j] = ToUpper(scope[i]);
 871                         }
 872
 873                         dst[lenpos] = (UBYTE)i;
 874                         lenpos += i + 1;
 875                         scope += i;
 876                 }
 877                 while('.' == (*scope++));
 878
 879                 dst[lenpos] = '\0';
 880         }
 881
 882         return(lenpos + 1);
 883 }
 884
 885 int
 886 BroadcastNameQuery(char *name, char *scope, UBYTE *address)
 887 {
 888         static const UBYTE header[12] =
 889         {
 890                 0x07, 0xB0,     /* 1964 == 0x07B0. */
 891                 0x01, 0x10,     /* Binary 0 0000 0010001 0000 */
 892                 0x00, 0x01,     /* One name query. */
 893                 0x00, 0x00,     /* Zero answers. */
 894                 0x00, 0x00,     /* Zero authorities. */
 895                 0x00, 0x00      /* Zero additional. */
 896         };
 897
 898         static const UBYTE query_tail[4] =
 899         {
 900                 0x00, 0x20,
 901                 0x00, 0x01
 902         };
 903
 904         struct timeval tv;
 905         fd_set read_fds;
 906         int sock_fd;
 907         int option_true = 1;
 908         struct sockaddr_in sox;
 909         struct nmb_header nmb_header;
 910         UBYTE buffer[512];
 911         int total_len;
 912         int i,n;
 913         int result;
 914         struct servent * s;
 915
 916         ENTER();
 917
 918         sock_fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
 919         if(sock_fd < 0)
 920         {
 921                 SHOWMSG("couldn't get the socket");
 922                 result = (-errno);
 923                 goto out;
 924         }
 925
 926         if(setsockopt(sock_fd, SOL_SOCKET, SO_BROADCAST, &option_true, sizeof(option_true)) < 0)
 927         {
 928                 SHOWMSG("couldn't enable the broadcast option");
 929                 result = (-errno);
 930                 goto out;
 931         }
 932
 933         sox.sin_family = AF_INET;
 934         sox.sin_addr.s_addr = htonl(0xFFFFFFFF);
 935
 936         s = getservbyname("netbios-ns","udp");
 937         if(s != NULL)
 938                 sox.sin_port = htons(s->s_port);
 939         else
 940                 sox.sin_port = htons(137);
 941
 942         memcpy(buffer, header, (total_len = sizeof(header)));
 943
 944         n = L2_Encode(&buffer[total_len], name, ' ', '\0', scope);
 945         if(n < 0)
 946         {
 947                 SHOWMSG("name encoding failed");
 948                 result = (-EINVAL);
 949                 goto out;
 950         }
 951
 952         total_len += n;
 953         memcpy(&buffer[total_len], query_tail, sizeof(query_tail));
 954         total_len += sizeof(query_tail);
 955
 956         result = (-ENOENT);
 957         n = 0;
 958
 959         /* Send the query packet; retry five times with a one second
 960          * delay in between.
 961          */
 962         for(i = 0 ; i < 5 ; i++)
 963         {
 964                 if(sendto(sock_fd, (void *) buffer, total_len, 0, (struct sockaddr *)&sox, sizeof(struct sockaddr_in)) < 0)
 965                 {
 966                         SHOWMSG("could not send the packet");
 967                         result = (-errno);
 968                         goto out;
 969                 }
 970
 971                 /* Wait for a response to arrive. */
 972                 tv.tv_secs = 1;
 973                 tv.tv_micro = 0;
 974
 975                 FD_ZERO(&read_fds);
 976                 FD_SET(sock_fd,&read_fds);
 977
 978                 if(WaitSelect(sock_fd+1, &read_fds, NULL, NULL, &tv, NULL) > 0)
 979                 {
 980                         n = recvfrom(sock_fd, buffer, sizeof(buffer), 0, NULL, NULL);
 981                         if(n < 0)
 982                         {
 983                                 SHOWMSG("could not pick up the response packet");
 984                                 result = (-errno);
 985                                 goto out;
 986                         }
 987                         else if (n > 0)
 988                         {
 989                                 break;
 990                         }
 991                 }
 992         }
 993
 994         /* Did we get anything at all? */
 995         if(n > (int)sizeof(nmb_header))
 996         {
 997                 /* Check whether the query was successful. */
 998                 memcpy(&nmb_header, buffer, sizeof(nmb_header));
 999                 if((nmb_header.flags & 0xF) == OK)
1000                 {
1001                         /* Find the NB/IP fields which directly follow
1002                          * the name.
1003                          */
1004                         for(i = sizeof(header) + strlen(&buffer[sizeof(header)])+1 ; i < n - (int)sizeof(query_tail) ; i++)
1005                         {
1006                                 if(memcmp(&buffer[i], query_tail, sizeof(query_tail)) == SAME)
1007                                 {
1008                                         int start;
1009
1010                                         /* This should be the start of the interesting bits;
1011                                          * we skip the NB/IP fields and the TTL field.
1012                                          */
1013                                         start = i + sizeof(query_tail) + sizeof(long);
1014                                         if(start < n)
1015                                         {
1016                                                 unsigned short read_len;
1017                                                 struct addr_entry addr_entry;
1018
1019                                                 /* This should be the read length. */
1020                                                 memcpy(&read_len, &buffer[start], 2);
1021
1022                                                 /* Is there any useful and readable data attached? */
1023                                                 if(read_len >= sizeof(addr_entry) &&
1024                                                    start + (int)sizeof(read_len) + (int)sizeof(addr_entry) <= n)
1025                                                 {
1026                                                         /* Copy a single address entry; this should be
1027                                                          * just the one we need.
1028                                                          */
1029                                                         memcpy(&addr_entry, &buffer[start + sizeof(read_len)], sizeof(addr_entry));
1030
1031                                                         /* Copy the address field (IPv4 only). */
1032                                                         memcpy(address, addr_entry.address, 4);
1033
1034                                                         result = 0;
1035                                                 }
1036                                         }
1037
1038                                         break;
1039                                 }
1040                         }
1041                 }
1042         }
1043
1044 out:
1045
1046         if(sock_fd >= 0)
1047                 CloseSocket(sock_fd);
1048
1049         RETURN(result);
1050         return(result);
1051 }
1052
1053 /****************************************************************************/
1054
1055 /* Send a disk change notification message which will be picked up
1056  * by all applications that listen for this kind of event, e.g.
1057  * Workbench.
1058  */
1059 STATIC VOID
1060 SendDiskChange(ULONG class)
1061 {
1062         struct IOStdReq * input_request = NULL;
1063         struct MsgPort * input_port;
1064         struct InputEvent ie;
1065
1066         ENTER();
1067
1068         input_port = CreateMsgPort();
1069         if(input_port == NULL)
1070                 goto out;
1071
1072         input_request = (struct IOStdReq *)CreateIORequest(input_port,sizeof(*input_request));
1073         if(input_request == NULL)
1074                 goto out;
1075
1076         if(OpenDevice("input.device",0,(struct IORequest *)input_request,0) != OK)
1077                 goto out;
1078
1079         memset(&ie,0,sizeof(ie));
1080
1081         ie.ie_Class             = class;
1082         ie.ie_Qualifier = IEQUALIFIER_MULTIBROADCAST;
1083
1084         GetSysTime(&ie.ie_TimeStamp);
1085
1086         input_request->io_Command       = IND_WRITEEVENT;
1087         input_request->io_Data          = &ie;
1088         input_request->io_Length        = sizeof(ie);
1089
1090         DoIO((struct IORequest *)input_request);
1091
1092  out:
1093
1094         if(input_request != NULL)
1095         {
1096                 if(input_request->io_Device != NULL)
1097                         CloseDevice((struct IORequest *)input_request);
1098
1099                 DeleteIORequest((struct IORequest *)input_request);
1100         }
1101
1102         DeleteMsgPort(input_port);
1103
1104         LEAVE();
1105 }
1106
1107 /****************************************************************************/
1108
1109 /* Find the file node corresponding to a given name,
1110  * skipping a particular entry if necessary.
1111  */
1112 STATIC struct FileNode *
1113 FindFileNode(STRPTR name,struct FileNode * skip)
1114 {
1115         struct FileNode * result = NULL;
1116         struct FileNode * fn;
1117
1118         for(fn = (struct FileNode *)FileList.mlh_Head ;
1119             fn->fn_MinNode.mln_Succ != NULL ;
1120             fn = (struct FileNode *)fn->fn_MinNode.mln_Succ)
1121         {
1122                 if(fn != skip && CompareNames(name,fn->fn_FullName) == SAME)
1123                 {
1124                         result = fn;
1125                         break;
1126                 }
1127         }
1128
1129         return(result);
1130 }
1131
1132 /* Find the lock node corresponding to a given name,
1133  * skipping a particular entry if necessary.
1134  */
1135 STATIC struct LockNode *
1136 FindLockNode(STRPTR name,struct LockNode * skip)
1137 {
1138         struct LockNode * result = NULL;
1139         struct LockNode * ln;
1140
1141         for(ln = (struct LockNode *)LockList.mlh_Head ;
1142             ln->ln_MinNode.mln_Succ != NULL ;
1143             ln = (struct LockNode *)ln->ln_MinNode.mln_Succ)
1144         {
1145                 if(ln != skip && CompareNames(name,ln->ln_FullName) == SAME)
1146                 {
1147                         result = ln;
1148                         break;
1149                 }
1150         }
1151
1152         return(result);
1153 }
1154
1155 /* Check whether a new reference to be made to a named
1156  * file will cause a conflict of access modes. No two
1157  * files and locks may refer to the same object if
1158  * either of these references is made in exclusive
1159  * mode. This is the case which this function is
1160  * trying to avoid.
1161  */
1162 STATIC LONG
1163 CheckAccessModeCollision(STRPTR name,LONG mode)
1164 {
1165         struct LockNode * ln;
1166         struct FileNode * fn;
1167         LONG error = OK;
1168
1169         ENTER();
1170         SHOWSTRING(name);
1171
1172         fn = FindFileNode(name,NULL);
1173         if(fn != NULL)
1174         {
1175                 if(mode != SHARED_LOCK || fn->fn_Mode != SHARED_LOCK)
1176                 {
1177                         D(("collides with '%s'",fn->fn_FullName));
1178                         error = ERROR_OBJECT_IN_USE;
1179                         goto out;
1180                 }
1181         }
1182
1183         ln = FindLockNode(name,NULL);
1184         if(ln != NULL)
1185         {
1186                 if(mode != SHARED_LOCK || ln->ln_FileLock.fl_Access != SHARED_LOCK)
1187                 {
1188                         D(("collides with '%s'",ln->ln_FullName));
1189                         error = ERROR_OBJECT_IN_USE;
1190                         goto out;
1191                 }
1192         }
1193
1194  out:
1195
1196         RETURN(error);
1197         return(error);
1198 }
1199
1200 /* Find out whether there already exists a reference to a
1201  * certain file or directory.
1202  */
1203 STATIC LONG
1204 NameAlreadyInUse(STRPTR name)
1205 {
1206         LONG error = OK;
1207
1208         ENTER();
1209
1210         if(FindFileNode(name,NULL) != NULL)
1211         {
1212                 error = ERROR_OBJECT_IN_USE;
1213                 goto out;
1214         }
1215
1216         if(FindLockNode(name,NULL) != NULL)
1217         {
1218                 error = ERROR_OBJECT_IN_USE;
1219                 goto out;
1220         }
1221
1222  out:
1223
1224         RETURN(error);
1225         return(error);
1226 }
1227
1228 /* Check whether an Amiga file name uses special characters which
1229  * should be avoided when used with the SMB file sharing protocol.
1230  */
1231 STATIC BOOL
1232 IsReservedName(STRPTR name)
1233 {
1234         BOOL result = FALSE;
1235
1236         /* Disallow "." and "..". */
1237         if(name[0] == '.' && (name[1] == '\0' || (name[1] == '.' && name[2] == '\0')))
1238         {
1239                 result = TRUE;
1240         }
1241         else
1242         {
1243                 UBYTE c;
1244
1245                 /* Disallow the use of the backslash in file names. */
1246                 while((c = (*name++)) != '\0')
1247                 {
1248                         if(c == SMB_PATH_SEPARATOR)
1249                         {
1250                                 result = TRUE;
1251                                 break;
1252                         }
1253                 }
1254         }
1255
1256         return(result);
1257 }
1258
1259 /****************************************************************************/
1260
1261 /* Convert a POSIX error code into an AmigaDOS error code. */
1262 STATIC LONG
1263 MapErrnoToIoErr(int error)
1264 {
1265         /* Not all of these mappings make good sense; bear in mind that
1266          * POSIX covers more than a hundred different error codes
1267          * whereas with AmigaDOS we're stranded with a measly 48...
1268          */
1269         STATIC const LONG Map[][2] =
1270         {
1271                 { EPERM,                        ERROR_OBJECT_NOT_FOUND },               /* Operation not permitted */
1272                 { ENOENT,                       ERROR_OBJECT_NOT_FOUND },               /* No such file or directory */
1273                 { ESRCH,                        ERROR_OBJECT_NOT_FOUND },               /* No such process */
1274                 { EINTR,                        ERROR_BREAK },                                  /* Interrupted system call */
1275                 { EIO,                          ERROR_OBJECT_IN_USE },                  /* Input/output error */
1276                 { E2BIG,                        ERROR_TOO_MANY_ARGS },                  /* Argument list too long */
1277                 { EBADF,                        ERROR_INVALID_LOCK },                   /* Bad file descriptor */
1278                 { ENOMEM,                       ERROR_NO_FREE_STORE },                  /* Cannot allocate memory */
1279                 { EACCES,                       ERROR_OBJECT_IN_USE },                  /* Permission denied */
1280 #ifdef ENOTBLK
1281                 { ENOTBLK,                      ERROR_OBJECT_WRONG_TYPE },              /* Block device required */
1282 #endif
1283                 { EBUSY,                        ERROR_OBJECT_IN_USE },                  /* Device busy */
1284                 { EEXIST,                       ERROR_OBJECT_EXISTS },                  /* File exists */
1285                 { EXDEV,                        ERROR_NOT_IMPLEMENTED },                /* Cross-device link */
1286                 { ENOTDIR,                      ERROR_OBJECT_WRONG_TYPE },              /* Not a directory */
1287                 { EISDIR,                       ERROR_OBJECT_WRONG_TYPE },              /* Is a directory */
1288                 { EINVAL,                       ERROR_BAD_NUMBER },                             /* Invalid argument */
1289                 { EFBIG,                        ERROR_DISK_FULL },                              /* File too large */
1290                 { ENOSPC,                       ERROR_DISK_FULL },                              /* No space left on device */
1291                 { ESPIPE,                       ERROR_SEEK_ERROR },                             /* Illegal seek */
1292                 { EROFS,                        ERROR_WRITE_PROTECTED },                /* Read-only file system */
1293                 { EMLINK,                       ERROR_TOO_MANY_LEVELS },                /* Too many links */
1294                 { ENOTSOCK,                     ERROR_OBJECT_WRONG_TYPE },              /* Socket operation on non-socket */
1295                 { EDESTADDRREQ,         ERROR_REQUIRED_ARG_MISSING },   /* Destination address required */
1296                 { EMSGSIZE,                     ERROR_LINE_TOO_LONG },                  /* Message too long */
1297                 { EPROTOTYPE,           ERROR_BAD_TEMPLATE },                   /* Protocol wrong type for socket */
1298                 { ENOPROTOOPT,          ERROR_NOT_IMPLEMENTED },                /* Protocol not available */
1299                 { EPROTONOSUPPORT,      ERROR_NOT_IMPLEMENTED },                /* Protocol not supported */
1300                 { ESOCKTNOSUPPORT,      ERROR_NOT_IMPLEMENTED },                /* Socket type not supported */
1301                 { EOPNOTSUPP,           ERROR_NOT_IMPLEMENTED },                /* Operation not supported */
1302                 { EPFNOSUPPORT,         ERROR_NOT_IMPLEMENTED },                /* Protocol family not supported */
1303                 { EAFNOSUPPORT,         ERROR_NOT_IMPLEMENTED },                /* Address family not supported by protocol family */
1304                 { EADDRINUSE,           ERROR_OBJECT_IN_USE },                  /* Address already in use */
1305                 { EADDRNOTAVAIL,        ERROR_OBJECT_NOT_FOUND },               /* Can't assign requested address */
1306                 { ENETDOWN,                     ERROR_OBJECT_NOT_FOUND },               /* Network is down */
1307                 { ENETUNREACH,          ERROR_OBJECT_NOT_FOUND },               /* Network is unreachable */
1308                 { ENETRESET,            ERROR_OBJECT_NOT_FOUND },               /* Network dropped connection on reset */
1309                 { ECONNABORTED,         ERROR_OBJECT_NOT_FOUND },               /* Software caused connection abort */
1310                 { ECONNRESET,           ERROR_OBJECT_NOT_FOUND },               /* Connection reset by peer */
1311                 { ENOBUFS,                      ERROR_DISK_FULL },                              /* No buffer space available */
1312                 { EISCONN,                      ERROR_OBJECT_IN_USE },                  /* Socket is already connected */
1313                 { ENOTCONN,                     ERROR_OBJECT_WRONG_TYPE },              /* Socket is not connected */
1314                 { ESHUTDOWN,            ERROR_INVALID_LOCK },                   /* Can't send after socket shutdown */
1315                 { ECONNREFUSED,         ERROR_OBJECT_IN_USE },                  /* Connection refused */
1316                 { ELOOP,                        ERROR_TOO_MANY_LEVELS },                /* Too many levels of symbolic links */
1317                 { ENAMETOOLONG,         ERROR_LINE_TOO_LONG },                  /* File name too long */
1318                 { EHOSTDOWN,            ERROR_OBJECT_NOT_FOUND },               /* Host is down */
1319                 { EHOSTUNREACH,         ERROR_OBJECT_NOT_FOUND },               /* No route to host */
1320                 { ENOTEMPTY,            ERROR_DIRECTORY_NOT_EMPTY },    /* Directory not empty */
1321                 { EPROCLIM,                     ERROR_TASK_TABLE_FULL },                /* Too many processes */
1322 #ifdef EUSERS
1323                 { EUSERS,                       ERROR_TASK_TABLE_FULL },                /* Too many users */
1324 #endif
1325                 { EDQUOT,                       ERROR_DISK_FULL },                              /* Disc quota exceeded */
1326                 { ENOLCK,                       ERROR_NOT_IMPLEMENTED },                /* no locks available */
1327                 { -1,                           -1 }
1328         };
1329
1330         LONG result = ERROR_ACTION_NOT_KNOWN;
1331         LONG i;
1332
1333         ENTER();
1334
1335         if(error < 0)
1336                 error = (-error);
1337
1338         for(i = 0 ; Map[i][0] != -1 ; i++)
1339         {
1340                 if(Map[i][0] == error)
1341                 {
1342                         result = Map[i][1];
1343                         break;
1344                 }
1345         }
1346
1347         RETURN(result);
1348         return(result);
1349 }
1350
1351 /****************************************************************************/
1352
1353 /* Translate a BCPL style file name (i.e. length is in the first byte)
1354  * via a mapping table.
1355  */
1356 INLINE STATIC VOID
1357 TranslateBName(UBYTE * name,UBYTE * map)
1358 {
1359         if(TranslateNames)
1360         {
1361                 LONG len;
1362                 UBYTE c;
1363
1364 #if !defined(N__AROS__)
1365                 len = (*name++);
1366 #else
1367                 len = AROS_BSTR_strlen(name);
1368                 name = AROS_BSTR_ADDR(name);
1369 #endif
1370                 while(len-- > 0)
1371                 {
1372                         c = (*name);
1373
1374                         (*name++) = map[c];
1375                 }
1376         }
1377 }
1378
1379 /* Translate a NUL terminated file name via a mapping table. */
1380 INLINE STATIC VOID
1381 TranslateCName(UBYTE * name,UBYTE * map)
1382 {
1383         if(TranslateNames)
1384         {
1385                 UBYTE c;
1386
1387                 while((c = (*name)) != '\0')
1388                         (*name++) = map[c];
1389         }
1390 }
1391
1392 /****************************************************************************/
1393
1394 /* Remove a DosList entry using the proper protocols. Note that
1395  * this function can fail!
1396  */
1397 STATIC BOOL
1398 ReallyRemoveDosEntry(struct DosList * entry)
1399 {
1400         struct Message * mn;
1401         struct MsgPort * port;
1402         struct DosList * dl;
1403         BOOL result = FALSE;
1404         LONG kind,i;
1405
1406         if(entry->dol_Type == DLT_DEVICE)
1407                 kind = LDF_DEVICES;
1408         else
1409                 kind = LDF_VOLUMES;
1410
1411         port = entry->dol_Task;
1412
1413         for(i = 0 ; i < 100 ; i++)
1414         {
1415                 dl = AttemptLockDosList(LDF_WRITE|kind);
1416                 if(((IPTR)dl) <= 1)
1417                         dl = NULL;
1418
1419                 if(dl != NULL)
1420                 {
1421                         RemDosEntry(entry);
1422
1423                         UnLockDosList(LDF_WRITE|kind);
1424
1425                         result = TRUE;
1426
1427                         break;
1428                 }
1429
1430                 while((mn = GetMsg(port)) != NULL)
1431                         ReplyPkt((struct DosPacket *)mn->mn_Node.ln_Name,DOSFALSE,ERROR_ACTION_NOT_KNOWN);
1432
1433                 Delay(TICKS_PER_SECOND / 10);
1434         }
1435
1436         return(result);
1437 }
1438
1439 /****************************************************************************/
1440
1441 /* Release all resources allocated by the Setup() routine. */
1442 STATIC VOID
1443 Cleanup(VOID)
1444 {
1445         BOOL send_disk_change = FALSE;
1446
1447         ENTER();
1448
1449         /* If any errors have cropped up, display them now before
1450          * call it quits.
1451          */
1452         DisplayErrorList();
1453
1454         if(Parameters != NULL)
1455         {
1456                 FreeArgs(Parameters);
1457                 FreeDosObject(DOS_RDARGS, Parameters);
1458                 Parameters = NULL;
1459         }
1460
1461         if(Icon != NULL)
1462         {
1463                 FreeDiskObject(Icon);
1464                 Icon = NULL;
1465         }
1466
1467         if(ServerData != NULL)
1468         {
1469                 smba_disconnect(ServerData);
1470                 ServerData = NULL;
1471         }
1472
1473         if(DeviceNode != NULL)
1474         {
1475                 if(ReallyRemoveDosEntry(DeviceNode))
1476                         FreeDosEntry(DeviceNode);
1477                 DeviceNode = NULL;
1478         }
1479
1480         if(VolumeNode != NULL)
1481         {
1482                 if(VolumeNodeAdded)
1483                 {
1484                         if(ReallyRemoveDosEntry(VolumeNode))
1485                                 FreeDosEntry(VolumeNode);
1486
1487                         send_disk_change = TRUE;
1488                 }
1489                 else
1490                 {
1491                         FreeDosEntry(VolumeNode);
1492                 }
1493
1494                 VolumeNode = NULL;
1495         }
1496
1497         if(FileSystemPort != NULL)
1498         {
1499                 struct Message * mn;
1500
1501                 /* Return all queued packets; there should be none, though. */
1502                 while((mn = GetMsg(FileSystemPort)) != NULL)
1503                         ReplyPkt((struct DosPacket *)mn->mn_Node.ln_Name,DOSFALSE,ERROR_ACTION_NOT_KNOWN);
1504         }
1505
1506         if(WBStartup == NULL && send_disk_change)
1507                 SendDiskChange(IECLASS_DISKREMOVED);
1508
1509         #if defined(__amigaos4__)
1510         {
1511                 if(ITimer != NULL)
1512                 {
1513                         DropInterface((struct Interface *)ITimer);
1514                         ITimer = NULL;
1515                 }
1516         }
1517         #endif /* __amigaos4__ */
1518
1519         if(TimerBase != NULL)
1520         {
1521                 if(TimerActive)
1522                 {
1523                         AbortIO((struct IORequest *)&TimerRequest);
1524                         WaitIO((struct IORequest *)&TimerRequest);
1525                 }
1526                 CloseDevice((struct IORequest *)&TimerRequest);
1527                 TimerBase = NULL;
1528         }
1529
1530         #if defined(__amigaos4__)
1531         {
1532                 if(ISocket != NULL)
1533                 {
1534                         DropInterface((struct Interface *)ISocket);
1535                         ISocket = NULL;
1536                 }
1537         }
1538         #endif /* __amigaos4__ */
1539
1540         if(SocketBase != NULL)
1541         {
1542                 CloseLibrary(SocketBase);
1543                 SocketBase = NULL;
1544         }
1545
1546         #if defined(__amigaos4__)
1547         {
1548                 if(IUtility != NULL)
1549                 {
1550                         DropInterface((struct Interface *)IUtility);
1551                         IUtility = NULL;
1552                 }
1553         }
1554         #endif /* __amigaos4__ */
1555
1556         if(UtilityBase != NULL)
1557         {
1558                 CloseLibrary(UtilityBase);
1559                 UtilityBase = NULL;
1560         }
1561
1562         #if defined(__amigaos4__)
1563         {
1564                 if(IIcon != NULL)
1565                 {
1566                         DropInterface((struct Interface *)IIcon);
1567                         IIcon = NULL;
1568                 }
1569         }
1570         #endif /* __amigaos4__ */
1571
1572         if(IconBase != NULL)
1573         {
1574                 CloseLibrary(IconBase);
1575                 IconBase = NULL;
1576         }
1577
1578         if(Locale != NULL)
1579         {
1580                 CloseLocale(Locale);
1581                 Locale = NULL;
1582         }
1583
1584         #if defined(__amigaos4__)
1585         {
1586                 if(ILocale != NULL)
1587                 {
1588                         DropInterface((struct Interface *)ILocale);
1589                         ILocale = NULL;
1590                 }
1591         }
1592         #endif /* __amigaos4__ */
1593
1594         if(LocaleBase != NULL)
1595         {
1596                 CloseLibrary(LocaleBase);
1597                 LocaleBase = NULL;
1598         }
1599
1600         if(MemoryPool != NULL)
1601         {
1602                 DeletePool(MemoryPool);
1603                 MemoryPool = NULL;
1604         }
1605
1606         #if defined(__amigaos4__)
1607         {
1608                 if(IDOS != NULL)
1609                 {
1610                         DropInterface((struct Interface *)IDOS);
1611                         IDOS = NULL;
1612                 }
1613         }
1614         #endif /* __amigaos4__ */
1615
1616         if(DOSBase != NULL)
1617         {
1618                 CloseLibrary(DOSBase);
1619                 DOSBase = NULL;
1620         }
1621
1622         if(WBStartup != NULL)
1623         {
1624                 Forbid();
1625                 ReplyMsg((struct Message *)WBStartup);
1626         }
1627
1628         LEAVE();
1629 }
1630
1631 /****************************************************************************/
1632
1633 /* Allocate all the necessary resources to get going. */
1634 STATIC BOOL
1635 Setup(
1636         STRPTR  opt_password,
1637         BOOL    opt_changecase,
1638         LONG *  opt_time_zone_offset,
1639         LONG *  opt_dst_offset,
1640         STRPTR  translation_file)
1641 {
1642         BOOL result = FALSE;
1643         int error = OK;
1644         LONG i;
1645
1646         ENTER();
1647
1648         NewList((struct List *)&FileList);
1649         NewList((struct List *)&LockList);
1650
1651         MemoryPool = CreatePool(MEMF_ANY|MEMF_PUBLIC,4096,4096);
1652         if(MemoryPool == NULL)
1653         {
1654                 ReportError("Could not create memory pool.");
1655                 goto out;
1656         }
1657
1658         LocaleBase = OpenLibrary("locale.library",38);
1659
1660         #if defined(__amigaos4__)
1661         {
1662                 if(LocaleBase != NULL)
1663                 {
1664                         ILocale = (struct LocaleIFace *)GetInterface(LocaleBase, "main", 1, 0);
1665                         if(ILocale == NULL)
1666                         {
1667                                 CloseLibrary(LocaleBase);
1668                                 LocaleBase = NULL;
1669                         }
1670                 }
1671         }
1672         #endif /* __amigaos4__ */
1673
1674         if(LocaleBase != NULL)
1675                 Locale = OpenLocale(NULL);
1676
1677         if(opt_time_zone_offset != NULL)
1678         {
1679                 TimeZoneOffset                  = (*opt_time_zone_offset);
1680                 OverrideLocaleTimeZone  = TRUE;
1681         }
1682
1683         if(opt_dst_offset != NULL)
1684                 DSTOffset = -60 * (*opt_dst_offset);
1685
1686         memset(&TimerRequest,0,sizeof(TimerRequest));
1687         TimerActive = FALSE;
1688
1689         if(OpenDevice(TIMERNAME,UNIT_VBLANK,(struct IORequest *)&TimerRequest,0) != OK)
1690         {
1691                 ReportError("Could not open 'timer.device'.");
1692                 goto out;
1693         }
1694
1695         TimerBase = (struct Library *)TimerRequest.tr_node.io_Device;
1696
1697         #if defined(__amigaos4__)
1698         {
1699                 if(TimerBase != NULL)
1700                 {
1701                         ITimer = (struct TimerIFace *)GetInterface(TimerBase, "main", 1, 0);
1702                         if(ITimer == NULL)
1703                         {
1704                                 ReportError("Could not open 'timer.device'.");
1705                                 goto out;
1706                         }
1707                 }
1708         }
1709         #endif /* __amigaos4__ */
1710
1711         SocketBase = OpenLibrary("bsdsocket.library",3);
1712
1713         #if defined(__amigaos4__)
1714         {
1715                 if(SocketBase != NULL)
1716                 {
1717                         ISocket = (struct SocketIFace *)GetInterface(SocketBase, "main", 1, 0);
1718                         if(ISocket == NULL)
1719                         {
1720                                 CloseLibrary(SocketBase);
1721                                 SocketBase = NULL;
1722                         }
1723                 }
1724         }
1725         #endif /* __amigaos4__ */
1726
1727         if(SocketBase == NULL)
1728         {
1729                 ReportError("Could not open 'bsdsocket.library' V3; TCP/IP stack not running?");
1730                 goto out;
1731         }
1732
1733         error = SocketBaseTags(
1734                 SBTM_SETVAL(SBTC_ERRNOPTR(sizeof(errno))),      &errno,
1735                 SBTM_SETVAL(SBTC_HERRNOLONGPTR),                        &h_errno,
1736                 SBTM_SETVAL(SBTC_LOGTAGPTR),                            HandlerName,
1737                 SBTM_SETVAL(SBTC_BREAKMASK),                            SIGBREAKF_CTRL_C,
1738         TAG_END);
1739         if(error != OK)
1740         {
1741                 ReportError("Could not initialize 'bsdsocket.library' (%ld, %s).",error,amitcp_strerror(error));
1742                 goto out;
1743         }
1744
1745         if(opt_changecase)
1746         {
1747                 for(i = 0 ; i < (LONG)strlen(opt_password) ; i++)
1748                         opt_password[i] = ToUpper(opt_password[i]);
1749         }
1750
1751         TranslateNames = FALSE;
1752
1753         /* Read the translation file, if possible. */
1754         if(translation_file != NULL)
1755         {
1756                 STRPTR msg = NULL;
1757                 BPTR file;
1758
1759                 error = OK;
1760
1761                 file = Open(translation_file,MODE_OLDFILE);
1762                 if(file != ZERO)
1763                 {
1764                         if(Read(file,A2M,256) != 256 ||
1765                            Read(file,M2A,256) != 256)
1766                         {
1767                                 msg = "Could not read translation file";
1768                                 error = IoErr();
1769                         }
1770
1771                         Close(file);
1772                 }
1773                 else
1774                 {
1775                         msg = "Could not open translation file";
1776                         error = IoErr();
1777                 }
1778
1779                 if(msg == NULL)
1780                 {
1781                         TranslateNames = TRUE;
1782                 }
1783                 else
1784                 {
1785                         UBYTE description[100];
1786
1787                         Fault(error,NULL,description,sizeof(description));
1788                         for(i = ((int)strlen(description)) - 1 ; i >= 0 ; i--)
1789                         {
1790                                 if(description[i] == '\n')
1791                                         description[i] = '\0';
1792                         }
1793
1794                         ReportError("%s '%s' (%ld, %s).",msg,translation_file,error,description);
1795                         goto out;
1796                 }
1797         }
1798
1799         result = TRUE;
1800
1801  out:
1802
1803         RETURN(result);
1804         return(result);
1805 }
1806
1807 /****************************************************************************/
1808
1809
1810 /* Make connection to server and make a volume for it. */
1811 STATIC BOOL
1812 AddVolume(
1813         STRPTR  service,
1814         STRPTR  workgroup,
1815         STRPTR  username,
1816         STRPTR  opt_password,
1817         STRPTR  opt_clientname,
1818         STRPTR  opt_servername,
1819         int             opt_cachesize,
1820         STRPTR  device_name,
1821         STRPTR  volume_name)
1822 {
1823         BOOL result = FALSE;
1824         int error = OK;
1825         STRPTR actual_volume_name;
1826         LONG actual_volume_name_len;
1827         UBYTE name[MAX_FILENAME_LEN];
1828         LONG i;
1829
1830         ENTER();
1831
1832         error = smba_start(service,workgroup,username,opt_password,opt_clientname,opt_servername,opt_cachesize,&ServerData);
1833         if(error < 0)
1834         {
1835                 StartReconnectTimer();
1836                 goto out;
1837         }
1838
1839         /* Examine the volume name; make sure that it is
1840          * well-formed.
1841          */
1842         if(volume_name == NULL)
1843                 actual_volume_name = device_name;
1844         else
1845                 actual_volume_name = volume_name;
1846
1847         actual_volume_name_len = strlen(actual_volume_name);
1848         if(actual_volume_name_len > 255)
1849                 actual_volume_name_len = 255;
1850
1851         for(i = 0 ; i < actual_volume_name_len ; i++)
1852         {
1853                 if(actual_volume_name[i] == '/')
1854                 {
1855                         ReportError("Volume name '%s' cannot be used with AmigaDOS.",actual_volume_name);
1856                         goto out;
1857                 }
1858         }
1859
1860         /* Lose any trailing colon characters. */
1861         for(i = actual_volume_name_len-1 ; i >= 0 ; i--)
1862         {
1863                 if(actual_volume_name[i] == ':')
1864                         actual_volume_name_len = i;
1865         }
1866
1867         if(actual_volume_name_len == 0)
1868         {
1869                 ReportError("Volume name '%s' cannot be used with AmigaDOS.",actual_volume_name);
1870                 goto out;
1871         }
1872
1873         /* Now, finally, take care of the volume name. */
1874         memcpy(name,actual_volume_name,actual_volume_name_len);
1875         name[actual_volume_name_len] = '\0';
1876
1877         VolumeNode = MakeDosEntry(name,DLT_VOLUME);
1878         if(VolumeNode == NULL)
1879         {
1880                 ReportError("Could not create volume node.");
1881                 goto out;
1882         }
1883
1884         VolumeNode->dol_Task = FileSystemPort;
1885         DateStamp(&VolumeNode->dol_misc.dol_volume.dol_VolumeDate);
1886         VolumeNode->dol_misc.dol_volume.dol_DiskType = ID_DOS_DISK;
1887
1888         /* Note: we always need the volume node to make some file
1889          *       system operations safe (e.g. Lock()), but we may
1890          *       not always need to make it visible.
1891          */
1892         if(volume_name != NULL && VolumeNode != NULL)
1893         {
1894                 AddDosEntry(VolumeNode);
1895                 VolumeNodeAdded = TRUE;
1896         }
1897
1898         /* Tell Workbench and friends to update their volume lists. */
1899         if(VolumeNodeAdded)
1900                 SendDiskChange(IECLASS_DISKINSERTED);
1901
1902         result = TRUE;
1903
1904  out:
1905
1906         RETURN(result);
1907         return(result);
1908 }
1909
1910 /****************************************************************************/
1911
1912
1913 /* Convert a BCPL string into a standard NUL terminated 'C' string. */
1914 INLINE STATIC VOID
1915 ConvertBString(LONG max_len,STRPTR cstring,APTR bstring)
1916 {
1917 #ifdef AROS_FAST_BSTR
1918         strncpy(cstring, bstring, max_len);
1919 #else
1920         STRPTR from = bstring;
1921         LONG len = from[0];
1922
1923         if(len > max_len-1)
1924                 len = max_len-1;
1925
1926         if(len > 0)
1927                 memcpy(cstring,from+1,len);
1928
1929         cstring[len] = '\0';
1930 #endif
1931 }
1932
1933 /* Convert a NUL terminated 'C' string into a BCPL string. */
1934 INLINE STATIC VOID
1935 ConvertCString(LONG max_len, APTR bstring, STRPTR cstring)
1936 {
1937         LONG len = strlen(cstring);
1938         STRPTR to = bstring;
1939
1940         if(len > max_len-1)
1941                 len = max_len-1;
1942
1943         (*to++) = len;
1944         memcpy(to,cstring,len);
1945 }
1946
1947 /****************************************************************************/
1948
1949 /* Build the fully qualified name of a file or directory in reference
1950  * to the name of the parent directory. This takes care of all the
1951  * special cases, such as the root directory. The result will be converted
1952  * to be in a form suitable for use with the SMB file sharing service.
1953  */
1954 STATIC LONG
1955 BuildFullName(
1956         STRPTR          parent_name,
1957         STRPTR          name,
1958         STRPTR *        result_ptr,
1959         LONG *          result_size_ptr)
1960 {
1961         LONG error = OK;
1962         STRPTR buffer;
1963         LONG len,size;
1964         LONG i;
1965
1966         ENTER();
1967
1968         SHOWSTRING(parent_name);
1969         SHOWSTRING(name);
1970
1971         (*result_ptr) = NULL;
1972
1973         /* Throw everything left of the colon away. */
1974         if(name != NULL)
1975         {
1976                 for(i = 0 ; i < (LONG)strlen(name) ; i++)
1977                 {
1978                         if(name[i] == ':')
1979                         {
1980                                 name = &name[i+1];
1981                                 break;
1982                         }
1983                 }
1984         }
1985
1986         /* Now, how much room is needed for the complete
1987          * path to fit into a buffer?
1988          */
1989         len = 2;
1990
1991         if(parent_name != NULL)
1992                 len += strlen(parent_name) + 1;
1993
1994         if(name != NULL)
1995                 len += strlen(name) + 1;
1996
1997         if(len < SMB_MAXNAMELEN)
1998                 len = SMB_MAXNAMELEN;
1999
2000         size = len + 3;
2001
2002         buffer = AllocateMemory(size);
2003         if(buffer == NULL)
2004         {
2005                 error = ERROR_NO_FREE_STORE;
2006                 goto out;
2007         }
2008
2009         /* Start by filling in the path name. */
2010         if(parent_name != NULL)
2011         {
2012                 /* Skip any excess separators. */
2013                 while((*parent_name) == SMB_PATH_SEPARATOR)
2014                         parent_name++;
2015
2016                 buffer[0] = SMB_PATH_SEPARATOR;
2017                 strcpy(&buffer[1],parent_name);
2018         }
2019         else
2020         {
2021                 strcpy(buffer,SMB_ROOT_DIR_NAME);
2022         }
2023
2024         /* If there's a name to add, do just that. */
2025         if(name != NULL)
2026         {
2027                 LONG segment_start;
2028                 LONG segment_len;
2029                 LONG buffer_len;
2030                 LONG name_len;
2031
2032                 buffer_len = strlen(buffer);
2033                 name_len = strlen(name);
2034
2035                 segment_start = 0;
2036
2037                 while(TRUE)
2038                 {
2039                         segment_len = 0;
2040
2041                         /* Extract the next path name segment. */
2042                         for(i = segment_start ; i <= name_len ; i++)
2043                         {
2044                                 if(i == name_len)
2045                                 {
2046                                         segment_len = i - segment_start;
2047                                         break;
2048                                 }
2049                                 else if (name[i] == '/')
2050                                 {
2051                                         segment_len = i - segment_start + 1;
2052                                         break;
2053                                 }
2054                         }
2055
2056                         /* We're finished if there are no further
2057                          * path name segments to take care of.
2058                          */
2059                         if(segment_len == 0)
2060                         {
2061                                 buffer[buffer_len] = '\0';
2062                                 break;
2063                         }
2064
2065                         /* A single slash indicates that we need to move up
2066                          * to the parent directory, if any.
2067                          */
2068                         if(segment_len == 1 && name[segment_start] == '/')
2069                         {
2070                                 /* Is this already the root directory name? */
2071                                 if(buffer_len <= 1)
2072                                 {
2073                                         FreeMemory(buffer);
2074                                         buffer = NULL;
2075
2076                                         goto out;
2077                                 }
2078                                 else
2079                                 {
2080                                         /* Skip the last path component. */
2081                                         for(i = 1 ; i <= buffer_len ; i++)
2082                                         {
2083                                                 if(i == buffer_len)
2084                                                 {
2085                                                         /* We just skipped the first path
2086                                                          * component following the root
2087                                                          * directory name. We preserve
2088                                                          * the first character since it
2089                                                          * refers to the root directory.
2090                                                          */
2091                                                         buffer_len = 1;
2092                                                         break;
2093                                                 }
2094                                                 else if (buffer[buffer_len-i] == SMB_PATH_SEPARATOR)
2095                                                 {
2096                                                         /* This removes both the path separator and
2097                                                          * the name following it.
2098                                                          */
2099                                                         buffer_len -= i;
2100                                                         break;
2101                                                 }
2102                                         }
2103                                 }
2104                         }
2105                         else
2106                         {
2107                                 /* Add a proper separator character if
2108                                  * necessary.
2109                                  */
2110                                 if(buffer_len > 0 && buffer[buffer_len-1] != SMB_PATH_SEPARATOR)
2111                                         buffer[buffer_len++] = SMB_PATH_SEPARATOR;
2112
2113                                 /* Find out how many characters are in that name; this
2114                                  * excludes the terminating slash.
2115                                  */
2116                                 if(name[segment_start + segment_len - 1] == '/')
2117                                         len = segment_len - 1;
2118                                 else
2119                                         len = segment_len;
2120
2121                                 memcpy(&buffer[buffer_len],&name[segment_start],len);
2122                                 buffer_len += len;
2123                         }
2124
2125                         segment_start += segment_len;
2126                 }
2127         }
2128
2129         (*result_ptr) = buffer;
2130         (*result_size_ptr) = size;
2131
2132         SHOWSTRING(buffer);
2133
2134  out:
2135
2136         if(error != OK)
2137                 FreeMemory(buffer);
2138
2139         RETURN(error);
2140         return(error);
2141 }
2142
2143 /****************************************************************************/
2144
2145 STATIC BOOL
2146 Action_Startup(
2147         struct FileSysStartupMsg *      fssm,
2148         struct DosList *                        device_node,
2149         SIPTR *                                         error_ptr)
2150 {
2151         UBYTE *control;
2152         LONG cache_size = 0;
2153         char env_workgroup_name[17];
2154         char env_service_name[17];
2155         char env_user_name[64];
2156         char env_password[64];
2157
2158         BOOL result = DOSTRUE;
2159         LONG error = 0;
2160
2161         ENTER();
2162
2163         DeviceNode = device_node;
2164         device_node->dol_Task = FileSystemPort;
2165
2166         memset(&args,0,sizeof(args));
2167
2168         Parameters = AllocDosObject(DOS_RDARGS, NULL);
2169         if(Parameters == NULL)
2170                 goto out;
2171         control = (UBYTE *)
2172                 ((struct DosEnvec *)BADDR(fssm->fssm_Environ))->de_Control;
2173         Parameters->RDA_Source.CS_Buffer = control;
2174         Parameters->RDA_Source.CS_Length = strlen(control);
2175         Parameters = ReadArgs(control_template,(IPTR *)&args,Parameters);
2176         if(Parameters == NULL)
2177         {
2178                 goto out;
2179         }
2180
2181         if(args.Workgroup == NULL)
2182         {
2183                 if(GetVar("smbfs_domain",env_workgroup_name,sizeof(env_workgroup_name),0) > 0 ||
2184                    GetVar("smbfs_workgroup",env_workgroup_name,sizeof(env_workgroup_name),0) > 0)
2185                 {
2186                         args.Workgroup = env_workgroup_name;
2187                 }
2188                 else
2189                 {
2190                         args.Workgroup = "WORKGROUP";
2191                 }
2192         }
2193
2194         if(args.UserName == NULL)
2195         {
2196                 if(GetVar("smbfs_user",env_user_name,sizeof(env_user_name),0) > 0 ||
2197                    GetVar("smbfs_username",env_user_name,sizeof(env_user_name),0) > 0)
2198                 {
2199                         args.UserName = env_user_name;
2200                 }
2201         }
2202
2203         if(args.Password == NULL)
2204         {
2205                 if(GetVar("smbfs_password",env_password,sizeof(env_password),0) > 0)
2206                         args.Password = env_password;
2207         }
2208
2209         if(args.Service == NULL)
2210         {
2211                 if(GetVar("smbfs_service",env_service_name,sizeof(env_service_name),0) > 0 ||
2212                    GetVar("smbfs_share",env_service_name,sizeof(env_service_name),0) > 0)
2213                 {
2214                         args.Service = env_service_name;
2215                 }
2216                 else
2217                 {
2218                         ReportError("Required 'SERVICE' parameter was not provided.");
2219                         goto out;
2220                 }
2221         }
2222
2223         if(args.CacheSize != NULL)
2224                 cache_size = (*args.CacheSize);
2225
2226         /* Use the default if no user name is given. */
2227         if(args.UserName == NULL)
2228                 args.UserName = "GUEST";
2229
2230         /* Volume name defaults to share name. */
2231         if(args.VolumeName == NULL)
2232                 args.VolumeName = FilePart(args.Service);
2233
2234         /* Use the default if no device or volume name is given. */
2235         if(args.DeviceName == NULL && args.VolumeName == NULL)
2236                 args.DeviceName = "SMBFS";
2237
2238         CaseSensitive = (BOOL)args.CaseSensitive;
2239         OmitHidden = (BOOL)args.OmitHidden;
2240
2241         /* Configure the debugging options. */
2242         if(args.DebugLevel != NULL)
2243                 SETDEBUGLEVEL(*args.DebugLevel);
2244         else
2245                 SETDEBUGLEVEL(0);
2246
2247         D(("%s (%s)",VERS,DATE));
2248
2249         if(Setup(
2250                 args.Password,
2251                 args.ChangeCase,
2252                 args.TimeZoneOffset,
2253                 args.DSTOffset,
2254                 args.TranslationFile))
2255         {
2256                 AddVolume(
2257                 args.Service,
2258                 args.Workgroup,
2259                 args.UserName,
2260                 args.Password,
2261                 args.ClientName,
2262                 args.ServerName,
2263                 cache_size,
2264                 args.DeviceName,
2265                 args.VolumeName);
2266         }
2267         else
2268         {
2269                 result = FALSE;
2270         }
2271
2272 out:
2273
2274         (*error_ptr) = error;
2275
2276         RETURN(result);
2277         return(result);
2278 }
2279
2280 /****************************************************************************/
2281
2282 STATIC BPTR
2283 Action_Parent(
2284         struct FileLock *       parent,
2285         SIPTR *                         error_ptr)
2286 {
2287         BPTR result = ZERO;
2288         STRPTR full_name = NULL;
2289         LONG full_name_size;
2290         STRPTR parent_name;
2291         BOOL cleanup = TRUE;
2292         struct LockNode * ln = NULL;
2293         LONG error;
2294
2295         ENTER();
2296
2297         SHOWVALUE(parent);
2298
2299         if(parent != NULL)
2300         {
2301                 struct LockNode * parent_ln = (struct LockNode *)parent->fl_Key;
2302
2303                 parent_name = parent_ln->ln_FullName;
2304         }
2305         else
2306         {
2307                 parent_name = NULL;
2308         }
2309
2310         error = BuildFullName(parent_name,"/",&full_name,&full_name_size);
2311         if(error != OK)
2312                 goto out;
2313
2314         /* Check if we ended up having to return the parent of
2315          * the root directory. This is indicated by a NULL
2316          * name pointer and a zero error code.
2317          */
2318         if(full_name == NULL)
2319                 goto out;
2320
2321         ln = AllocateMemory(sizeof(*ln));
2322         if(ln == NULL)
2323         {
2324                 error = ERROR_NO_FREE_STORE;
2325                 goto out;
2326         }
2327
2328         memset(ln,0,sizeof(*ln));
2329
2330         ln->ln_FileLock.fl_Key          = (IPTR)ln;
2331         ln->ln_FileLock.fl_Access       = SHARED_LOCK;
2332         ln->ln_FileLock.fl_Task         = FileSystemPort;
2333         ln->ln_FileLock.fl_Volume       = MKBADDR(VolumeNode);
2334         ln->ln_FullName                         = full_name;
2335
2336         SHOWSTRING(full_name);
2337
2338         error = smba_open(ServerData,full_name,full_name_size,&ln->ln_File);
2339         if(error < 0)
2340         {
2341                 error = MapErrnoToIoErr(error);
2342                 goto out;
2343         }
2344
2345         AddTail((struct List *)&LockList,(struct Node *)ln);
2346         result = MKBADDR(&ln->ln_FileLock);
2347         cleanup = FALSE;
2348         SHOWVALUE(&ln->ln_FileLock);
2349
2350  out:
2351
2352         if(cleanup)
2353         {
2354                 FreeMemory(full_name);
2355                 FreeMemory(ln);
2356         }
2357
2358         (*error_ptr) = error;
2359
2360         RETURN(result);
2361         return(result);
2362 }
2363
2364 /****************************************************************************/
2365
2366 /* Find the lock node corresponding to a given name,
2367  * starting from node start. (if node, this one is skipped)
2368  */
2369 STATIC struct LockNode *
2370 FindNextLockNode(STRPTR name,struct LockNode * last_ln)
2371 {
2372         struct LockNode * result = NULL;
2373         struct LockNode * ln;
2374         struct LockNode * start;
2375
2376         if(last_ln != NULL)
2377                 start = (struct LockNode *)last_ln->ln_MinNode.mln_Succ;
2378         else
2379                 start = (struct LockNode *)LockList.mlh_Head;
2380
2381         for(ln = start ;
2382             ln->ln_MinNode.mln_Succ != NULL ;
2383             ln = (struct LockNode *)ln->ln_MinNode.mln_Succ)
2384         {
2385                 if(CompareNames(name,ln->ln_FullName) == SAME)
2386                 {
2387                         result = ln;
2388                         break;
2389                 }
2390         }
2391
2392         return(result);
2393 }
2394
2395 /****************************************************************************/
2396
2397 STATIC LONG
2398 Action_DeleteObject(
2399         struct FileLock *       parent,
2400         APTR                            bcpl_name,
2401         SIPTR *                         error_ptr)
2402 {
2403         LONG result = DOSFALSE;
2404         STRPTR full_name = NULL;
2405         LONG full_name_size;
2406         smba_file_t * file = NULL;
2407         STRPTR parent_name;
2408         STRPTR full_parent_name = NULL;
2409         UBYTE name[MAX_FILENAME_LEN];
2410         struct LockNode * ln;
2411         smba_stat_t st;
2412         LONG error;
2413
2414         ENTER();
2415
2416         if(WriteProtected)
2417         {
2418                 error = ERROR_DISK_WRITE_PROTECTED;
2419                 goto out;
2420         }
2421
2422         SHOWVALUE(parent);
2423
2424         if(parent != NULL)
2425         {
2426                 ln = (struct LockNode *)parent->fl_Key;
2427
2428                 parent_name = ln->ln_FullName;
2429         }
2430         else
2431         {
2432                 parent_name = NULL;
2433         }
2434
2435         ConvertBString(sizeof(name),name,bcpl_name);
2436         TranslateCName(name,A2M);
2437
2438         error = BuildFullName(parent_name,name,&full_name,&full_name_size);
2439         if(error != OK)
2440                 goto out;
2441
2442         /* Trying to delete the root directory, are you kidding? */
2443         if(full_name == NULL)
2444         {
2445                 error = ERROR_OBJECT_WRONG_TYPE;
2446                 goto out;
2447         }
2448
2449         /* We need to find this file's parent directory, so that
2450          * in case the directory contents are currently being
2451          * examined, that process is restarted.
2452          */
2453         full_parent_name = AllocateMemory(strlen(full_name)+3);
2454         if(full_parent_name == NULL)
2455         {
2456                 error = ERROR_NO_FREE_STORE;
2457                 goto out;
2458         }
2459
2460         strcpy(full_parent_name,full_name);
2461
2462         /* Build the parent object name - Piru */
2463         if (full_parent_name[0] != '\0')
2464         {
2465                 int i;
2466
2467                 i = strlen(full_parent_name) - 1;
2468                 if (full_parent_name[i] == SMB_PATH_SEPARATOR)
2469                         i--;
2470
2471                 for ( ; i >= 0 ; i--)
2472                 {
2473                         if (full_parent_name[i] == SMB_PATH_SEPARATOR)
2474                         {
2475                                 full_parent_name[i] = '\0';
2476                                 break;
2477                         }
2478                 }
2479         }
2480
2481         /* NOTE: Mark all locks to this object as restart, not just first
2482            one - Piru */
2483         ln = NULL;
2484         while ((ln = FindNextLockNode(full_parent_name, ln)) != NULL)
2485                 ln->ln_RestartExamine = TRUE;
2486
2487         ln = FindLockNode(full_parent_name,NULL);
2488         if(ln != NULL)
2489                 ln->ln_RestartExamine = TRUE;
2490
2491         FreeMemory(full_parent_name);
2492         full_parent_name = NULL;
2493
2494         SHOWSTRING(full_name);
2495
2496         error = smba_open(ServerData,full_name,full_name_size,&file);
2497         if(error < 0)
2498         {
2499                 error = MapErrnoToIoErr(error);
2500                 goto out;
2501         }
2502
2503         error = smba_getattr(file,&st);
2504         if(error < 0)
2505         {
2506                 error = MapErrnoToIoErr(error);
2507                 goto out;
2508         }
2509
2510         smba_close(file);
2511         file = NULL;
2512
2513         if(st.is_dir)
2514         {
2515                 SHOWMSG("removing a directory");
2516
2517                 error = smba_rmdir(ServerData,full_name);
2518                 if(error < 0)
2519                 {
2520                         SHOWVALUE(error);
2521
2522                         /* This is a little bit difficult to justify since
2523                          * the error code may indicate a different cause,
2524                          * but in practice 'EACCES' seems to be returned
2525                          * if the directory to remove is not empty.
2526                          */
2527                         if(error == (-EACCES))
2528                                 error = ERROR_DIRECTORY_NOT_EMPTY;
2529                         else
2530                                 error = MapErrnoToIoErr(error);
2531
2532                         goto out;
2533                 }
2534         }
2535         else
2536         {
2537                 SHOWMSG("removing a file");
2538
2539                 error = smba_remove(ServerData,full_name);
2540                 if(error < 0)
2541                 {
2542                         SHOWVALUE(error);
2543
2544                         error = MapErrnoToIoErr(error);
2545                         goto out;
2546                 }
2547         }
2548
2549         SHOWMSG("done.");
2550
2551         result = DOSTRUE;
2552
2553  out:
2554
2555         FreeMemory(full_name);
2556         FreeMemory(full_parent_name);
2557         if(file != NULL)
2558                 smba_close(file);
2559
2560         (*error_ptr) = error;
2561
2562         RETURN(result);
2563         return(result);
2564 }
2565
2566 /****************************************************************************/
2567
2568 STATIC BPTR
2569 Action_CreateDir(
2570         struct FileLock *       parent,
2571         APTR                            bcpl_name,
2572         SIPTR *                         error_ptr)
2573 {
2574         BPTR result = ZERO;
2575         STRPTR full_name = NULL;
2576         LONG full_name_size;
2577         struct LockNode * ln = NULL;
2578         STRPTR parent_name;
2579         STRPTR dir_name = NULL;
2580         smba_file_t * dir = NULL;
2581         STRPTR base_name;
2582         UBYTE name[MAX_FILENAME_LEN];
2583         LONG error;
2584         LONG i;
2585
2586         ENTER();
2587
2588         if(WriteProtected)
2589         {
2590                 error = ERROR_DISK_WRITE_PROTECTED;
2591                 goto out;
2592         }
2593
2594         SHOWVALUE(parent);
2595
2596         if(parent != NULL)
2597         {
2598                 struct LockNode * parent_ln = (struct LockNode *)parent->fl_Key;
2599
2600                 parent_name = parent_ln->ln_FullName;
2601         }
2602         else
2603         {
2604                 parent_name = NULL;
2605         }
2606
2607         ConvertBString(sizeof(name),name,bcpl_name);
2608         TranslateCName(name,A2M);
2609
2610         error = BuildFullName(parent_name,name,&full_name,&full_name_size);
2611         if(error != OK)
2612                 goto out;
2613
2614         /* Trying to overwrite the root directory, are you kidding? */
2615         if(full_name == NULL)
2616         {
2617                 error = ERROR_OBJECT_IN_USE;
2618                 goto out;
2619         }
2620
2621         dir_name = AllocateMemory(strlen(full_name)+3);
2622         if(dir_name == NULL)
2623         {
2624                 error = ERROR_NO_FREE_STORE;
2625                 goto out;
2626         }
2627
2628         strcpy(dir_name,full_name);
2629         base_name = NULL;
2630         for(i = strlen(dir_name)-1 ; i >= 0 ; i--)
2631         {
2632                 if(dir_name[i] == SMB_PATH_SEPARATOR)
2633                 {
2634                         if(i == 0)
2635                         {
2636                                 memmove(&dir_name[1],&dir_name[0],strlen(dir_name)+1);
2637                                 i++;
2638                         }
2639
2640                         dir_name[i] = '\0';
2641
2642                         base_name = &dir_name[i+1];
2643                         break;
2644                 }
2645         }
2646
2647         ln = AllocateMemory(sizeof(*ln));
2648         if(ln == NULL)
2649         {
2650                 error = ERROR_NO_FREE_STORE;
2651                 goto out;
2652         }
2653
2654         memset(ln,0,sizeof(*ln));
2655
2656         ln->ln_FileLock.fl_Key          = (IPTR)ln;
2657         ln->ln_FileLock.fl_Access       = EXCLUSIVE_LOCK;
2658         ln->ln_FileLock.fl_Task         = FileSystemPort;
2659         ln->ln_FileLock.fl_Volume       = MKBADDR(VolumeNode);
2660         ln->ln_FullName                         = full_name;
2661
2662         error = smba_open(ServerData,dir_name,strlen(full_name)+3,&dir);
2663         if(error < 0)
2664         {
2665                 error = MapErrnoToIoErr(error);
2666                 goto out;
2667         }
2668
2669         error = smba_mkdir(dir,base_name);
2670         if(error < 0)
2671         {
2672                 error = MapErrnoToIoErr(error);
2673                 goto out;
2674         }
2675
2676         smba_close(dir);
2677         dir = NULL;
2678
2679         SHOWSTRING(full_name);
2680
2681         error = smba_open(ServerData,full_name,full_name_size,&ln->ln_File);
2682         if(error < 0)
2683         {
2684                 error = MapErrnoToIoErr(error);
2685                 goto out;
2686         }
2687
2688         AddTail((struct List *)&LockList,(struct Node *)ln);
2689         result = MKBADDR(&ln->ln_FileLock);
2690         SHOWVALUE(&ln->ln_FileLock);
2691
2692  out:
2693
2694         if(dir != NULL)
2695                 smba_close(dir);
2696
2697         FreeMemory(dir_name);
2698
2699         if(result == ZERO)
2700         {
2701                 FreeMemory(full_name);
2702                 FreeMemory(ln);
2703         }
2704
2705         (*error_ptr) = error;
2706
2707         RETURN(result);
2708         return(result);
2709 }
2710
2711 /****************************************************************************/
2712
2713 STATIC BPTR
2714 Action_LocateObject(
2715         struct FileLock *       parent,
2716         APTR                            bcpl_name,
2717         LONG                            mode,
2718         SIPTR *                         error_ptr)
2719 {
2720         BPTR result = ZERO;
2721         STRPTR full_name = NULL;
2722         LONG full_name_size;
2723         struct LockNode * ln = NULL;
2724         STRPTR parent_name;
2725         UBYTE name[MAX_FILENAME_LEN];
2726         LONG error;
2727
2728         ENTER();
2729
2730         SHOWVALUE(parent);
2731
2732         if(parent != NULL)
2733         {
2734                 struct LockNode * parent_ln = (struct LockNode *)parent->fl_Key;
2735
2736                 parent_name = parent_ln->ln_FullName;
2737         }
2738         else
2739         {
2740                 parent_name = NULL;
2741         }
2742
2743         ConvertBString(sizeof(name),name,bcpl_name);
2744         TranslateCName(name,A2M);
2745
2746         if(IsReservedName(FilePart(name)))
2747         {
2748                 error = ERROR_OBJECT_NOT_FOUND;
2749                 goto out;
2750         }
2751
2752         error = BuildFullName(parent_name,name,&full_name,&full_name_size);
2753         if(error != OK)
2754                 goto out;
2755
2756         /* Trying to get a lock on the root directory's parent?
2757          * My pleasure.
2758          */
2759         if(full_name == NULL)
2760         {
2761                 error = ERROR_OBJECT_NOT_FOUND;
2762                 goto out;
2763         }
2764
2765         ln = AllocateMemory(sizeof(*ln));
2766         if(ln == NULL)
2767         {
2768                 error = ERROR_NO_FREE_STORE;
2769                 goto out;
2770         }
2771
2772         memset(ln,0,sizeof(*ln));
2773
2774         ln->ln_FileLock.fl_Key          = (IPTR)ln;
2775         ln->ln_FileLock.fl_Access       = (mode != EXCLUSIVE_LOCK) ? SHARED_LOCK : EXCLUSIVE_LOCK;
2776         ln->ln_FileLock.fl_Task         = FileSystemPort;
2777         ln->ln_FileLock.fl_Volume       = MKBADDR(VolumeNode);
2778         ln->ln_FullName                         = full_name;
2779
2780         error = CheckAccessModeCollision(full_name,ln->ln_FileLock.fl_Access);
2781         if(error != OK)
2782                 goto out;
2783
2784         SHOWSTRING(full_name);
2785
2786         error = smba_open(ServerData,full_name,full_name_size,&ln->ln_File);
2787         if(error < 0)
2788         {
2789                 error = MapErrnoToIoErr(error);
2790                 goto out;
2791         }
2792
2793         AddTail((struct List *)&LockList,(struct Node *)ln);
2794         result = MKBADDR(&ln->ln_FileLock);
2795         SHOWVALUE(&ln->ln_FileLock);
2796
2797  out:
2798
2799         if(result == ZERO)
2800         {
2801                 FreeMemory(full_name);
2802                 FreeMemory(ln);
2803         }
2804
2805         (*error_ptr) = error;
2806
2807         RETURN(result);
2808         return(result);
2809 }
2810
2811 /****************************************************************************/
2812
2813 STATIC BPTR
2814 Action_CopyDir(
2815         struct FileLock *       lock,
2816         SIPTR *                         error_ptr)
2817 {
2818         BPTR result = ZERO;
2819         STRPTR full_name = NULL;
2820         LONG full_name_size;
2821         struct LockNode * ln = NULL;
2822         STRPTR source_name;
2823         LONG source_mode;
2824         LONG error;
2825
2826         ENTER();
2827
2828         SHOWVALUE(lock);
2829
2830         if(lock != NULL && lock->fl_Access != SHARED_LOCK)
2831         {
2832                 SHOWMSG("cannot duplicate exclusive lock");
2833                 error = ERROR_OBJECT_IN_USE;
2834                 goto out;
2835         }
2836
2837         ln = AllocateMemory(sizeof(*ln));
2838         if(ln == NULL)
2839         {
2840                 error = ERROR_NO_FREE_STORE;
2841                 goto out;
2842         }
2843
2844         memset(ln,0,sizeof(*ln));
2845
2846         if(lock != NULL)
2847         {
2848                 struct LockNode * source = (struct LockNode *)lock->fl_Key;
2849
2850                 source_name = source->ln_FullName;
2851                 source_mode = source->ln_FileLock.fl_Access;
2852         }
2853         else
2854         {
2855                 source_name = SMB_ROOT_DIR_NAME;
2856                 source_mode = SHARED_LOCK;
2857         }
2858
2859         full_name_size = strlen(source_name)+3;
2860         if(full_name_size < SMB_MAXNAMELEN+1)
2861                 full_name_size = SMB_MAXNAMELEN+1;
2862
2863         full_name = AllocateMemory(full_name_size);
2864         if(full_name == NULL)
2865         {
2866                 error = ERROR_NO_FREE_STORE;
2867                 goto out;
2868         }
2869
2870         strcpy(full_name,source_name);
2871
2872         ln->ln_FileLock.fl_Key          = (IPTR)ln;
2873         ln->ln_FileLock.fl_Access       = source_mode;
2874         ln->ln_FileLock.fl_Task         = FileSystemPort;
2875         ln->ln_FileLock.fl_Volume       = MKBADDR(VolumeNode);
2876         ln->ln_FullName                         = full_name;
2877
2878         SHOWSTRING(full_name);
2879
2880         error = smba_open(ServerData,full_name,full_name_size,&ln->ln_File);
2881         if(error < 0)
2882         {
2883                 error = MapErrnoToIoErr(error);
2884                 goto out;
2885         }
2886
2887         AddTail((struct List *)&LockList,(struct Node *)ln);
2888         result = MKBADDR(&ln->ln_FileLock);
2889         SHOWVALUE(&ln->ln_FileLock);
2890
2891  out:
2892
2893         if(result == ZERO)
2894         {
2895                 FreeMemory(full_name);
2896                 FreeMemory(ln);
2897         }
2898
2899         (*error_ptr) = error;
2900
2901         RETURN(result);
2902         return(result);
2903 }
2904
2905 /****************************************************************************/
2906
2907 STATIC LONG
2908 Action_FreeLock(
2909         struct FileLock *       lock,
2910         SIPTR *                         error_ptr)
2911 {
2912         LONG result = DOSTRUE;
2913         struct LockNode * ln;
2914         LONG error = OK;
2915
2916         ENTER();
2917
2918         SHOWVALUE(lock);
2919
2920         if(lock == NULL)
2921                 goto out;
2922
2923         ln = (struct LockNode *)lock->fl_Key;
2924
2925         Remove((struct Node *)ln);
2926         smba_close(ln->ln_File);
2927         FreeMemory(ln->ln_FullName);
2928         FreeMemory(ln);
2929
2930  out:
2931
2932         (*error_ptr) = error;
2933
2934         RETURN(result);
2935         return(result);
2936 }
2937
2938 /****************************************************************************/
2939
2940 STATIC LONG
2941 Action_SameLock(
2942         struct FileLock *       lock1,
2943         struct FileLock *       lock2,
2944         SIPTR *                         error_ptr)
2945 {
2946         LONG result = DOSFALSE;
2947         STRPTR name1;
2948         STRPTR name2;
2949         LONG error = OK;
2950
2951         ENTER();
2952
2953         SHOWVALUE(lock1);
2954         SHOWVALUE(lock2);
2955
2956         if(lock1 != NULL)
2957         {
2958                 struct LockNode * ln = (struct LockNode *)lock1->fl_Key;
2959
2960                 name1 = ln->ln_FullName;
2961         }
2962         else
2963         {
2964                 name1 = SMB_ROOT_DIR_NAME;
2965         }
2966
2967         if(lock2 != NULL)
2968         {
2969                 struct LockNode * ln = (struct LockNode *)lock2->fl_Key;
2970
2971                 name2 = ln->ln_FullName;
2972         }
2973         else
2974         {
2975                 name2 = SMB_ROOT_DIR_NAME;
2976         }
2977
2978         SHOWSTRING(name1);
2979         SHOWSTRING(name2);
2980
2981         if(Stricmp(name1,name2) == SAME)
2982                 result = DOSTRUE;
2983
2984         (*error_ptr) = error;
2985
2986         RETURN(result);
2987         return(result);
2988 }
2989
2990 /****************************************************************************/
2991
2992 STATIC LONG
2993 Action_SetProtect(
2994         struct FileLock *       parent,
2995         APTR                            bcpl_name,
2996         LONG                            mask,
2997         SIPTR *                         error_ptr)
2998 {
2999         LONG result = DOSFALSE;
3000         STRPTR full_name = NULL;
3001         LONG full_name_size;
3002         smba_file_t * file = NULL;
3003         STRPTR parent_name;
3004         UBYTE name[MAX_FILENAME_LEN];
3005         smba_stat_t st;
3006         LONG error;
3007
3008         ENTER();
3009
3010         if(WriteProtected)
3011         {
3012                 error = ERROR_DISK_WRITE_PROTECTED;
3013                 goto out;
3014         }
3015
3016         SHOWVALUE(parent);
3017
3018         if(parent != NULL)
3019         {
3020                 struct LockNode * ln = (struct LockNode *)parent->fl_Key;
3021
3022                 parent_name = ln->ln_FullName;
3023         }
3024         else
3025         {
3026                 parent_name = NULL;
3027         }
3028
3029         ConvertBString(sizeof(name),name,bcpl_name);
3030         TranslateCName(name,A2M);
3031
3032         error = BuildFullName(parent_name,name,&full_name,&full_name_size);
3033         if(error != OK)
3034                 goto out;
3035
3036         /* Trying to change the protection bits of the root
3037          * directory, are you kidding?
3038          */
3039         if(full_name == NULL)
3040         {
3041                 error = ERROR_OBJECT_WRONG_TYPE;
3042                 goto out;
3043         }
3044
3045         SHOWSTRING(full_name);
3046
3047         error = smba_open(ServerData,full_name,full_name_size,&file);
3048         if(error < 0)
3049         {
3050                 error = MapErrnoToIoErr(error);
3051                 goto out;
3052         }
3053
3054         memset(&st,0,sizeof(st));
3055
3056         mask ^= FIBF_READ | FIBF_WRITE | FIBF_EXECUTE | FIBF_DELETE;
3057
3058         st.atime = -1;
3059         st.ctime = -1;
3060         st.mtime = -1;
3061         st.size = -1;
3062
3063         if((mask & (FIBF_WRITE|FIBF_DELETE)) != (FIBF_WRITE|FIBF_DELETE))
3064         {
3065                 SHOWMSG("write protection enabled");
3066                 st.is_wp = TRUE;
3067         }
3068         else
3069         {
3070                 SHOWMSG("write protection disabled");
3071         }
3072
3073         /* Careful: the 'archive' attribute has exactly the opposite
3074          *          meaning in the Amiga and the SMB worlds.
3075          */
3076         st.is_archive = ((mask & FIBF_ARCHIVE) == 0);
3077
3078         /* The 'system' attribute is associated with the 'pure' bit for now. */
3079         st.is_system = ((mask & FIBF_PURE) != 0);
3080
3081         error = smba_setattr(file,&st);
3082         if(error < 0)
3083         {
3084                 error = MapErrnoToIoErr(error);
3085                 goto out;
3086         }
3087
3088         result = DOSTRUE;
3089
3090  out:
3091
3092         FreeMemory(full_name);
3093         if(file != NULL)
3094                 smba_close(file);
3095
3096         (*error_ptr) = error;
3097
3098         RETURN(result);
3099         return(result);
3100 }
3101
3102 /****************************************************************************/
3103
3104 STATIC LONG
3105 Action_RenameObject(
3106         struct FileLock *       source_lock,
3107         APTR                            source_bcpl_name,
3108         struct FileLock *       destination_lock,
3109         APTR                            destination_bcpl_name,
3110         SIPTR *                         error_ptr)
3111 {
3112         struct LockNode * ln;
3113         LONG result = DOSFALSE;
3114         STRPTR full_source_name = NULL;
3115         LONG full_source_name_size;
3116         STRPTR full_destination_name = NULL;
3117         LONG full_destination_name_size;
3118         UBYTE name[MAX_FILENAME_LEN];
3119         STRPTR parent_name;
3120         LONG error;
3121
3122         ENTER();
3123
3124         if(WriteProtected)
3125         {
3126                 error = ERROR_DISK_WRITE_PROTECTED;
3127                 goto out;
3128         }
3129
3130         SHOWVALUE(source_lock);
3131         SHOWVALUE(destination_lock);
3132
3133         if(source_lock != NULL)
3134         {
3135                 ln = (struct LockNode *)source_lock->fl_Key;
3136
3137                 parent_name = ln->ln_FullName;
3138         }
3139         else
3140         {
3141                 parent_name = NULL;
3142         }
3143
3144         ConvertBString(sizeof(name),name,source_bcpl_name);
3145         TranslateCName(name,A2M);
3146
3147         error = BuildFullName(parent_name,name,&full_source_name,&full_source_name_size);
3148         if(error != OK)
3149                 goto out;
3150
3151         /* Trying to rename the root directory, are you kidding? */
3152         if(full_source_name == NULL)
3153         {
3154                 error = ERROR_OBJECT_IN_USE;
3155                 goto out;
3156         }
3157
3158         if(destination_lock != NULL)
3159         {
3160                 ln = (struct LockNode *)destination_lock->fl_Key;
3161
3162                 parent_name = ln->ln_FullName;
3163         }
3164         else
3165         {
3166                 parent_name = NULL;
3167         }
3168
3169         ConvertBString(sizeof(name),name,destination_bcpl_name);
3170         TranslateCName(name,A2M);
3171
3172         error = BuildFullName(parent_name,name,&full_destination_name,&full_destination_name_size);
3173         if(error != OK)
3174                 goto out;
3175
3176         /* Trying to rename the root directory, are you kidding? */
3177         if(full_destination_name == NULL)
3178         {
3179                 error = ERROR_OBJECT_IN_USE;
3180                 goto out;
3181         }
3182
3183         error = NameAlreadyInUse(full_source_name);
3184         if(error != OK)
3185                 goto out;
3186
3187         error = NameAlreadyInUse(full_destination_name);
3188         if(error != OK)
3189                 goto out;
3190
3191         SHOWSTRING(full_source_name);
3192         SHOWSTRING(full_destination_name);
3193
3194         error = smba_rename(ServerData,full_source_name,full_destination_name);
3195         if(error < 0)
3196         {
3197                 error = MapErrnoToIoErr(error);
3198                 goto out;
3199         }
3200
3201         result = DOSTRUE;
3202
3203  out:
3204
3205         FreeMemory(full_source_name);
3206         FreeMemory(full_destination_name);
3207
3208         (*error_ptr) = error;
3209
3210         RETURN(result);
3211         return(result);
3212 }
3213
3214 /****************************************************************************/
3215
3216 STATIC LONG
3217 Action_DiskInfo(
3218         struct InfoData *       id,
3219         SIPTR *                         error_ptr)
3220 {
3221         LONG result = DOSTRUE;
3222         long block_size;
3223         long num_blocks;
3224         long num_blocks_free;
3225         LONG error;
3226
3227         ENTER();
3228
3229         memset(id,0,sizeof(*id));
3230
3231         if(WriteProtected)
3232                 id->id_DiskState = ID_WRITE_PROTECTED;
3233         else
3234                 id->id_DiskState = ID_VALIDATED;
3235
3236         error = smba_statfs(ServerData,&block_size,&num_blocks,&num_blocks_free);
3237         if(error >= 0)
3238         {
3239                 SHOWMSG("got the disk data");
3240                 SHOWVALUE(block_size);
3241                 SHOWVALUE(num_blocks);
3242                 SHOWVALUE(num_blocks_free);
3243
3244                 if(block_size <= 0)
3245                         block_size = 512;
3246
3247                 if(block_size < 512)
3248                 {
3249                         num_blocks              /= (512 / block_size);
3250                         num_blocks_free /= (512 / block_size);
3251                 }
3252                 else if (block_size > 512)
3253                 {
3254                         num_blocks              *= (block_size / 512);
3255                         num_blocks_free *= (block_size / 512);
3256                 }
3257
3258                 id->id_NumBlocks                = num_blocks;
3259                 id->id_NumBlocksUsed    = num_blocks - num_blocks_free;
3260                 id->id_BytesPerBlock    = 512;
3261                 id->id_DiskType                 = ID_DOS_DISK;
3262                 id->id_VolumeNode               = MKBADDR(VolumeNode);
3263                 id->id_InUse                    = NOT (IsListEmpty((struct List *)&FileList) && IsListEmpty((struct List *)&LockList));
3264
3265                 if(id->id_NumBlocks == 0)
3266                         id->id_NumBlocks = 1;
3267
3268                 if(id->id_NumBlocksUsed == 0)
3269                         id->id_NumBlocksUsed = 1;
3270         }
3271         else
3272         {
3273                 SHOWMSG("could not get any disk data");
3274
3275                 id->id_NumBlocks                = 1;
3276                 id->id_NumBlocksUsed    = 1;
3277                 id->id_BytesPerBlock    = 512;
3278                 id->id_DiskType                 = ID_NO_DISK_PRESENT;
3279
3280                 error = MapErrnoToIoErr(error);
3281                 result = DOSFALSE;
3282         }
3283
3284         SHOWVALUE(id->id_NumBlocks);
3285         SHOWVALUE(id->id_NumBlocksUsed);
3286         SHOWVALUE(id->id_BytesPerBlock);
3287         SHOWVALUE(id->id_DiskType);
3288         SHOWVALUE(id->id_VolumeNode);
3289         SHOWVALUE(id->id_InUse);
3290
3291         (*error_ptr) = error;
3292
3293         RETURN(result);
3294         return(result);
3295 }
3296
3297 STATIC LONG
3298 Action_Info(
3299         struct FileLock *       lock,
3300         struct InfoData *       id,
3301         SIPTR *                         error_ptr)
3302 {
3303         LONG result;
3304
3305         ENTER();
3306
3307         SHOWVALUE(lock);
3308
3309         if(lock == NULL || lock->fl_Volume != MKBADDR(VolumeNode))
3310         {
3311                 SHOWMSG("volume node does not match");
3312
3313                 result = DOSFALSE;
3314
3315                 (*error_ptr) = ERROR_NO_DISK;
3316         }
3317         else
3318         {
3319                 result = Action_DiskInfo(id,error_ptr);
3320         }
3321
3322         RETURN(result);
3323         return(result);
3324 }
3325
3326 /****************************************************************************/
3327
3328 STATIC LONG
3329 Action_ExamineObject(
3330         struct FileLock *               lock,
3331         struct FileInfoBlock *  fib,
3332         SIPTR *                                 error_ptr)
3333 {
3334         LONG result = DOSFALSE;
3335         LONG error = OK;
3336
3337         ENTER();
3338
3339         SHOWVALUE(lock);
3340
3341         memset(fib,0,sizeof(*fib));
3342
3343         if(lock == NULL)
3344         {
3345 #if !defined(__AROS__)
3346                 STRPTR volume_name = BADDR(VolumeNode->dol_Name);
3347                 LONG len = volume_name[0];
3348
3349                 memcpy(fib->fib_FileName+1, volume_name + 1, len);
3350                 fib->fib_FileName[0] = len;
3351 #else
3352                 STRPTR volume_name = AROS_BSTR_ADDR(VolumeNode->dol_Name);
3353                 LONG len = AROS_BSTR_strlen(VolumeNode->dol_Name);
3354
3355                 memcpy(fib->fib_FileName + 1, volume_name, len);
3356                 fib->fib_FileName[0] = len;
3357 #endif
3358                 SHOWMSG("ZERO root lock");
3359
3360                 fib->fib_DirEntryType   = ST_ROOT;
3361                 fib->fib_EntryType              = ST_ROOT;
3362                 fib->fib_NumBlocks              = 1;
3363                 fib->fib_Date                   = VolumeNode->dol_misc.dol_volume.dol_VolumeDate;
3364                 fib->fib_DiskKey                = -1;
3365                 fib->fib_Protection             = FIBF_OTR_READ|FIBF_OTR_EXECUTE|FIBF_OTR_WRITE|FIBF_OTR_DELETE|
3366                                                                   FIBF_GRP_READ|FIBF_GRP_EXECUTE|FIBF_GRP_WRITE|FIBF_GRP_DELETE;
3367         }
3368         else
3369         {
3370                 struct LockNode * ln = (struct LockNode *)lock->fl_Key;
3371                 LONG seconds;
3372                 smba_stat_t st;
3373
3374                 error = smba_getattr(ln->ln_File,&st);
3375                 if(error < 0)
3376                 {
3377                         SHOWMSG("information not available");
3378
3379                         error = MapErrnoToIoErr(error);
3380                         goto out;
3381                 }
3382
3383                 seconds = st.mtime - UNIX_TIME_OFFSET - GetTimeZoneDelta();
3384                 if(seconds < 0)
3385                         seconds = 0;
3386
3387                 fib->fib_Date.ds_Days   = (seconds / (24 * 60 * 60));
3388                 fib->fib_Date.ds_Minute = (seconds % (24 * 60 * 60)) / 60;
3389                 fib->fib_Date.ds_Tick   = (seconds % 60) * TICKS_PER_SECOND;
3390
3391                 SHOWSTRING(ln->ln_FullName);
3392
3393                 if(strcmp(ln->ln_FullName,SMB_ROOT_DIR_NAME) == SAME)
3394                 {
3395 #if !defined(__AROS__)
3396                         STRPTR volume_name = BADDR(VolumeNode->dol_Name);
3397                         LONG len = volume_name[0];
3398
3399                         memcpy(fib->fib_FileName+1, volume_name + 1, len);
3400                         fib->fib_FileName[0] = len;
3401 #else
3402                         STRPTR volume_name = AROS_BSTR_ADDR(VolumeNode->dol_Name);
3403                         LONG len = AROS_BSTR_strlen(VolumeNode->dol_Name);
3404
3405                         memcpy(fib->fib_FileName + 1, volume_name, len);
3406                         fib->fib_FileName[0] = len;
3407 #endif
3408                         SHOWMSG("root lock");
3409
3410                         fib->fib_DirEntryType   = ST_ROOT;
3411                         fib->fib_EntryType              = ST_ROOT;
3412                         fib->fib_NumBlocks              = 1;
3413                         fib->fib_Protection             = FIBF_OTR_READ|FIBF_OTR_EXECUTE|FIBF_OTR_WRITE|FIBF_OTR_DELETE|
3414                                                                           FIBF_GRP_READ|FIBF_GRP_EXECUTE|FIBF_GRP_WRITE|FIBF_GRP_DELETE;
3415                 }
3416                 else
3417                 {
3418                         STRPTR name;
3419                         LONG i;
3420
3421                         name = ln->ln_FullName;
3422                         for(i = strlen(name)-1 ; i >= 0 ; i--)
3423                         {
3424                                 if(name[i] == SMB_PATH_SEPARATOR)
3425                                 {
3426                                         name = &name[i+1];
3427                                         break;
3428                                 }
3429                         }
3430
3431                         /* Just checking: will the name fit? */
3432                         if(strlen(name) >= sizeof(fib->fib_FileName))
3433                         {
3434                                 error = ERROR_INVALID_COMPONENT_NAME;
3435                                 goto out;
3436                         }
3437
3438                         ConvertCString(sizeof(fib->fib_FileName),fib->fib_FileName,name);
3439                         TranslateBName(fib->fib_FileName,M2A);
3440
3441                         fib->fib_DirEntryType   = st.is_dir ? ST_USERDIR : ST_FILE;
3442                         fib->fib_EntryType              = fib->fib_DirEntryType;
3443                         fib->fib_NumBlocks              = (st.size + 511) / 512;
3444                         fib->fib_Size                   = st.size;
3445                         fib->fib_Protection             = FIBF_OTR_READ|FIBF_OTR_EXECUTE|FIBF_OTR_WRITE|FIBF_OTR_DELETE|
3446                                                                           FIBF_GRP_READ|FIBF_GRP_EXECUTE|FIBF_GRP_WRITE|FIBF_GRP_DELETE;
3447
3448                         if(st.is_wp)
3449                                 fib->fib_Protection ^= (FIBF_OTR_WRITE|FIBF_OTR_DELETE|FIBF_GRP_WRITE|FIBF_GRP_DELETE|FIBF_WRITE|FIBF_DELETE);
3450
3451                         /* Careful: the 'archive' attribute has exactly the opposite
3452                          *          meaning in the Amiga and the SMB worlds.
3453                          */
3454                         if(NOT st.is_archive)
3455                                 fib->fib_Protection |= FIBF_ARCHIVE;
3456
3457                         if(st.is_system)
3458                                 fib->fib_Protection |= FIBF_PURE;
3459
3460                         if(NOT st.is_dir)
3461                                 fib->fib_DiskKey = -1;
3462                 }
3463         }
3464
3465         result = DOSTRUE;
3466
3467         D(("fib->fib_FileName = \"%b\"",MKBADDR(fib->fib_FileName)));
3468         SHOWVALUE(fib->fib_DirEntryType);
3469         SHOWVALUE(fib->fib_NumBlocks);
3470         SHOWVALUE(fib->fib_Size);
3471         SHOWVALUE(fib->fib_Date.ds_Days);
3472         SHOWVALUE(fib->fib_Date.ds_Minute);
3473         SHOWVALUE(fib->fib_Date.ds_Tick);
3474         SHOWVALUE(fib->fib_DiskKey);
3475
3476  out:
3477
3478         (*error_ptr) = error;
3479
3480         RETURN(result);
3481         return(result);
3482 }
3483
3484 /****************************************************************************/
3485
3486 STATIC BOOL
3487 NameIsAcceptable(STRPTR name,LONG max_len)
3488 {
3489         BOOL result = FALSE;
3490         UBYTE c;
3491
3492         /* This takes care of "." and "..". */
3493         if(name[0] == '.' && (name[1] == '\0' || (name[1] == '.' && name[2] == '\0')))
3494                 goto out;
3495
3496         /* Now for embedded '/', ':' and '\' characters and
3497          * names that just don't want to fit.
3498          */
3499         while((c = (*name++)) != '\0')
3500         {
3501                 max_len--;
3502                 if(max_len == 0 || c == '/' || c == ':' || c == SMB_PATH_SEPARATOR)
3503                         goto out;
3504         }
3505
3506         result = TRUE;
3507
3508  out:
3509
3510         return(result);
3511 }
3512
3513 /****************************************************************************/
3514
3515 static int
3516 dir_scan_callback_func_exnext(
3517         struct FileInfoBlock *  fib,
3518         int                                             unused_fpos,
3519         int                                             nextpos,
3520         char *                                  name,
3521         int                                             eof,
3522         smba_stat_t *                   st)
3523 {
3524         int result;
3525
3526         ENTER();
3527
3528         D((" '%s'",name));
3529         D(("   is_dir=%ld is_wp=%ld is_hidden=%ld size=%ld",
3530                 st->is_dir,st->is_wp,st->is_hidden,st->size));
3531         D(("   nextpos=%ld eof=%ld",nextpos,eof));
3532
3533         /* Skip file and drawer names that we wouldn't be
3534          * able to handle in the first place.
3535          */
3536         if(NameIsAcceptable((STRPTR)name,sizeof(fib->fib_FileName)) && NOT (st->is_hidden && OmitHidden))
3537         {
3538                 LONG seconds;
3539
3540                 ConvertCString(sizeof(fib->fib_FileName),fib->fib_FileName,name);
3541                 TranslateBName(fib->fib_FileName,M2A);
3542
3543                 fib->fib_DirEntryType   = st->is_dir ? ST_USERDIR : ST_FILE;
3544                 fib->fib_EntryType              = fib->fib_DirEntryType;
3545                 fib->fib_NumBlocks              = (st->size + 511) / 512;
3546                 fib->fib_Size                   = st->size;
3547                 fib->fib_Protection             = FIBF_OTR_READ|FIBF_OTR_EXECUTE|FIBF_OTR_WRITE|FIBF_OTR_DELETE|
3548                                                                   FIBF_GRP_READ|FIBF_GRP_EXECUTE|FIBF_GRP_WRITE|FIBF_GRP_DELETE;
3549
3550                 if(st->is_wp)
3551                         fib->fib_Protection ^= (FIBF_OTR_WRITE|FIBF_OTR_DELETE|FIBF_GRP_WRITE|FIBF_GRP_DELETE|FIBF_WRITE|FIBF_DELETE);
3552
3553                 /* Careful: the 'archive' attribute has exactly the opposite
3554                  *          meaning in the Amiga and the SMB worlds.
3555                  */
3556                 if(NOT st->is_archive)
3557                         fib->fib_Protection |= FIBF_ARCHIVE;
3558
3559                 if(st->is_system)
3560                         fib->fib_Protection |= FIBF_PURE;
3561
3562                 seconds = st->mtime - UNIX_TIME_OFFSET - GetTimeZoneDelta();
3563                 if(seconds < 0)
3564                         seconds = 0;
3565
3566                 fib->fib_Date.ds_Days   = (seconds / (24 * 60 * 60));
3567                 fib->fib_Date.ds_Minute = (seconds % (24 * 60 * 60)) / 60;
3568                 fib->fib_Date.ds_Tick   = (seconds % 60) * TICKS_PER_SECOND;
3569
3570                 result = 1;
3571         }
3572         else
3573         {
3574                 result = 0;
3575         }
3576
3577         fib->fib_DiskKey = eof ? -1 : nextpos;
3578
3579         RETURN(result);
3580         return(result);
3581 }
3582
3583 STATIC LONG
3584 Action_ExamineNext(
3585         struct FileLock *               lock,
3586         struct FileInfoBlock *  fib,
3587         SIPTR *                                 error_ptr)
3588 {
3589         struct LockNode * ln;
3590         LONG result = DOSFALSE;
3591         LONG error = OK;
3592         long offset;
3593         int count;
3594
3595         ENTER();
3596
3597         SHOWVALUE(lock);
3598
3599         if(fib->fib_DiskKey == -1)
3600         {
3601                 SHOWMSG("scanning finished.");
3602                 error = ERROR_NO_MORE_ENTRIES;
3603                 goto out;
3604         }
3605
3606         if(lock == NULL)
3607         {
3608                 SHOWMSG("invalid lock");
3609                 error = ERROR_INVALID_LOCK;
3610                 goto out;
3611         }
3612
3613         offset = fib->fib_DiskKey;
3614
3615         ln = (struct LockNode *)lock->fl_Key;
3616
3617         /* Check if we should restart scanning the directory
3618          * contents. This is tricky at best and may produce
3619          * irritating results :(
3620          */
3621         if(ln->ln_RestartExamine)
3622         {
3623                 offset = 0;
3624
3625                 ln->ln_RestartExamine = FALSE;
3626         }
3627
3628         memset(fib,0,sizeof(*fib));
3629
3630         SHOWMSG("calling 'smba_readdir'");
3631         SHOWVALUE(offset);
3632
3633         count = smba_readdir(ln->ln_File,offset,fib,(smba_callback_t)dir_scan_callback_func_exnext);
3634
3635         SHOWVALUE(count);
3636
3637         if(count == 0 || fib->fib_FileName[0] == '\0')
3638         {
3639                 SHOWMSG("nothing to be read");
3640                 fib->fib_DiskKey = -1;
3641
3642                 error = ERROR_NO_MORE_ENTRIES;
3643                 goto out;
3644         }
3645         else if (count == (-EIO))
3646         {
3647                 SHOWMSG("ouch! directory read error");
3648                 fib->fib_DiskKey = -1;
3649
3650                 error = ERROR_NO_DEFAULT_DIR;
3651                 goto out;
3652         }
3653         else if (count < 0)
3654         {
3655                 SHOWMSG("error whilst scanning");
3656                 SHOWVALUE(count);
3657                 fib->fib_DiskKey = -1;
3658
3659                 error = MapErrnoToIoErr(count);
3660                 goto out;
3661         }
3662
3663         result = DOSTRUE;
3664
3665  out:
3666
3667         (*error_ptr) = error;
3668
3669         RETURN(result);
3670         return(result);
3671 }
3672
3673 /****************************************************************************/
3674
3675 struct ExAllContext
3676 {
3677         struct ExAllData *              ec_Last;
3678         struct ExAllData *              ec_Next;
3679         ULONG                                   ec_BytesLeft;
3680         ULONG                                   ec_MinSize;
3681         struct ExAllControl *   ec_Control;
3682         ULONG                                   ec_Type;
3683         LONG                                    ec_Error;
3684         BOOL                                    ec_FirstAttempt;
3685 };
3686
3687 static int
3688 dir_scan_callback_func_exall(
3689         struct ExAllContext *   ec,
3690         int                                             unused_fpos,
3691         int                                             nextpos,
3692         char *                                  name,
3693         int                                             eof,
3694         smba_stat_t *                   st)
3695 {
3696         int result = 0;
3697
3698         ENTER();
3699
3700         D((" '%s'",name));
3701         D(("   is_dir=%ld is_wp=%ld is_hidden=%ld size=%ld",
3702                 st->is_dir,st->is_wp,st->is_hidden,st->size));
3703         D(("   nextpos=%ld eof=%ld",nextpos,eof));
3704
3705         /* Skip file and drawer names that we wouldn't be
3706          * able to handle in the first place.
3707          */
3708         if(NameIsAcceptable((STRPTR)name,MAX_FILENAME_LEN) && NOT (st->is_hidden && OmitHidden))
3709         {
3710                 struct ExAllData * ed;
3711                 ULONG size;
3712                 ULONG type = ec->ec_Type;
3713                 BOOL take_it;
3714
3715                 size = (ec->ec_MinSize + strlen(name)+1 + 3) & ~3UL;
3716                 SHOWVALUE(size);
3717                 if(size > ec->ec_BytesLeft)
3718                 {
3719                         D(("size %ld > ec->ec_BytesLeft %ld",size,ec->ec_BytesLeft));
3720
3721                         /* If this is the first directory entry,
3722                          * stop the entire process before it has
3723                          * really begun.
3724                          */
3725                         if(ec->ec_FirstAttempt)
3726                         {
3727                                 SHOWMSG("this was the first read attempt.");
3728                                 ec->ec_Control->eac_Entries = 0;
3729                                 ec->ec_Error = ERROR_NO_FREE_STORE;
3730                         }
3731                         else
3732                         {
3733                                 SHOWMSG("try again");
3734                                 ec->ec_Error = 0;
3735                         }
3736
3737                         result = 1;
3738                         goto out;
3739                 }
3740
3741                 ed = ec->ec_Next;
3742
3743                 ed->ed_Next = NULL;
3744                 ed->ed_Name = (STRPTR)(((IPTR)ed) + ec->ec_MinSize);
3745                 strcpy(ed->ed_Name,name);
3746
3747                 TranslateCName(ed->ed_Name,M2A);
3748
3749                 if(type >= ED_TYPE)
3750                         ed->ed_Type = st->is_dir ? ST_USERDIR : ST_FILE;
3751
3752                 if(type >= ED_SIZE)
3753                         ed->ed_Size = st->size;
3754
3755                 if(type >= ED_PROTECTION)
3756                 {
3757                         ed->ed_Prot = FIBF_OTR_READ|FIBF_OTR_EXECUTE|FIBF_OTR_WRITE|FIBF_OTR_DELETE|
3758                                       FIBF_GRP_READ|FIBF_GRP_EXECUTE|FIBF_GRP_WRITE|FIBF_GRP_DELETE;
3759
3760                         if(st->is_wp)
3761                                 ed->ed_Prot ^= (FIBF_OTR_WRITE|FIBF_OTR_DELETE|FIBF_GRP_WRITE|FIBF_GRP_DELETE|FIBF_WRITE|FIBF_DELETE);
3762
3763                         /* Careful: the 'archive' attribute has exactly the opposite
3764                          *          meaning in the Amiga and the SMB worlds.
3765                          */
3766                         if(NOT st->is_archive)
3767                                 ed->ed_Prot |= FIBF_ARCHIVE;
3768
3769                         if(st->is_system)
3770                                 ed->ed_Prot |= FIBF_PURE;
3771                 }
3772
3773                 if(type >= ED_DATE)
3774                 {
3775                         LONG seconds;
3776
3777                         seconds = st->mtime - UNIX_TIME_OFFSET - GetTimeZoneDelta();
3778                         if(seconds < 0)
3779                                 seconds = 0;
3780
3781                         ed->ed_Days             = (seconds / (24 * 60 * 60));
3782                         ed->ed_Mins     = (seconds % (24 * 60 * 60)) / 60;
3783                         ed->ed_Ticks    = (seconds % 60) * TICKS_PER_SECOND;
3784                 }
3785
3786                 if(type >= ED_COMMENT)
3787                         ed->ed_Comment = "";
3788
3789                 if(type >= ED_OWNER)
3790                         ed->ed_OwnerUID = ed->ed_OwnerGID = 0;
3791
3792                 take_it = TRUE;
3793
3794                 if(ec->ec_Control->eac_MatchString != NULL)
3795                 {
3796                         SHOWMSG("checking against match string");
3797                         if(NOT MatchPatternNoCase(ec->ec_Control->eac_MatchString,ed->ed_Name))
3798                         {
3799                                 SHOWMSG("does not match");
3800                                 take_it = FALSE;
3801                         }
3802                 }
3803
3804                 if(take_it && ec->ec_Control->eac_MatchFunc != NULL)
3805                 {
3806                         SHOWMSG("calling match func");
3807
3808                         /* NOTE: the order of the parameters passed to the match hook
3809                          *       function can be somewhat confusing. For standard
3810                          *       hook functions, the order of the parameters and the
3811                          *       registers they go into is hook=A0, object=A2,
3812                          *       message=A1. However, the documentation for the 'ExAll()'
3813                          *       function always lists them in ascending order, that is
3814                          *       hook=A0, message=A1, object=A2, which can lead to
3815                          *       quite some confusion and strange errors.
3816                          */
3817                         if(NOT CallHookPkt(ec->ec_Control->eac_MatchFunc,&type,ed))
3818                         {
3819                                 SHOWMSG("does not match");
3820                                 take_it = FALSE;
3821                         }
3822                 }
3823
3824                 if(take_it)
3825                 {
3826                         SHOWMSG("registering new entry");
3827
3828                         if(ec->ec_Last != NULL)
3829                                 ec->ec_Last->ed_Next = ed;
3830
3831                         ec->ec_Last = ed;
3832                         ec->ec_Next = (struct ExAllData *)(((IPTR)ed) + size);
3833                         ec->ec_BytesLeft -= size;
3834                         ec->ec_Control->eac_Entries++;
3835
3836                         SHOWVALUE(ec->ec_Last->ed_Next);
3837                         SHOWVALUE(ed->ed_Name);
3838                         SHOWVALUE(ed->ed_Comment);
3839                 }
3840         }
3841
3842         ec->ec_Control->eac_LastKey = (ULONG)(eof ? -1 : nextpos);
3843
3844  out:
3845
3846         ec->ec_FirstAttempt = FALSE;
3847
3848         RETURN(result);
3849         return(result);
3850 }
3851
3852 STATIC LONG
3853 Action_ExamineAll(
3854         struct FileLock *               lock,
3855         struct ExAllData *              ed,
3856         ULONG                                   size,
3857         ULONG                                   type,
3858         struct ExAllControl *   eac,
3859         SIPTR *                                 error_ptr)
3860 {
3861         struct ExAllContext ec;
3862         struct LockNode * ln;
3863         LONG result = DOSFALSE;
3864         LONG error = OK;
3865         LONG offset;
3866         int count;
3867
3868         ENTER();
3869
3870         SHOWVALUE(lock);
3871
3872         SHOWVALUE(eac->eac_LastKey);
3873
3874         eac->eac_Entries = 0;
3875
3876         if(size < sizeof(ed->ed_Next))
3877         {
3878                 SHOWMSG("buffer is far too short.");
3879                 error = ERROR_NO_FREE_STORE;
3880                 goto out;
3881         }
3882
3883         ed->ed_Next = NULL;
3884
3885         if(eac->eac_LastKey == (ULONG)-1)
3886         {
3887                 SHOWMSG("scanning finished.");
3888                 error = ERROR_NO_MORE_ENTRIES;
3889                 goto out;
3890         }
3891
3892         if(lock == NULL)
3893         {
3894                 SHOWMSG("invalid lock");
3895                 error = ERROR_INVALID_LOCK;
3896                 goto out;
3897         }
3898
3899         if(type < ED_NAME || type > ED_OWNER)
3900         {
3901                 D(("type %ld not supported",type));
3902                 error = ERROR_BAD_NUMBER;
3903                 goto out;
3904         }
3905
3906         SHOWVALUE(type);
3907
3908         memset(&ec,0,sizeof(ec));
3909
3910         ec.ec_Next                      = ed;
3911         ec.ec_BytesLeft         = size;
3912         ec.ec_Control           = eac;
3913         ec.ec_Type                      = type;
3914         ec.ec_Error                     = ERROR_NO_MORE_ENTRIES;
3915         ec.ec_FirstAttempt      = TRUE;
3916
3917         switch(type)
3918         {
3919                 case ED_NAME:
3920
3921                         ec.ec_MinSize = offsetof(struct ExAllData,ed_Type);
3922                         break;
3923
3924                 case ED_TYPE:
3925
3926                         ec.ec_MinSize = offsetof(struct ExAllData,ed_Size);
3927                         break;
3928
3929                 case ED_SIZE:
3930
3931                         ec.ec_MinSize = offsetof(struct ExAllData,ed_Prot);
3932                         break;
3933
3934                 case ED_PROTECTION:
3935
3936                         ec.ec_MinSize = offsetof(struct ExAllData,ed_Days);
3937                         break;
3938
3939                 case ED_DATE:
3940
3941                         ec.ec_MinSize = offsetof(struct ExAllData,ed_Comment);
3942                         break;
3943
3944                 case ED_COMMENT:
3945
3946                         ec.ec_MinSize = offsetof(struct ExAllData,ed_OwnerUID);
3947                         break;
3948
3949                 case ED_OWNER:
3950
3951                         ec.ec_MinSize = sizeof(struct ExAllData);
3952                         break;
3953         }
3954
3955         SHOWVALUE(ec.ec_MinSize);
3956
3957         offset = eac->eac_LastKey;
3958
3959         ln = (struct LockNode *)lock->fl_Key;
3960
3961         /* Check if we should restart scanning the directory
3962          * contents. This is tricky at best and may produce
3963          * irritating results :(
3964          */
3965         if(ln->ln_RestartExamine)
3966         {
3967                 offset = 0;
3968
3969                 ln->ln_RestartExamine = FALSE;
3970         }
3971
3972         if(offset == 0)
3973         {
3974                 smba_stat_t st;
3975
3976                 SHOWMSG("first invocation");
3977
3978                 SHOWMSG("getting file attributes");
3979                 error = smba_getattr(ln->ln_File,&st);
3980                 if(error < 0)
3981                 {
3982                         SHOWMSG("didn't work");
3983                         error = MapErrnoToIoErr(error);
3984                         eac->eac_LastKey = (ULONG)-1;
3985                         goto out;
3986                 }
3987
3988                 if(NOT st.is_dir)
3989                 {
3990                         SHOWMSG("lock does not refer to a directory");
3991                         error = ERROR_OBJECT_WRONG_TYPE;
3992                         eac->eac_LastKey = (ULONG)-1;
3993                         goto out;
3994                 }
3995         }
3996
3997         SHOWMSG("calling 'smba_readdir'");
3998         SHOWVALUE(offset);
3999
4000         count = smba_readdir(ln->ln_File,offset,&ec,(smba_callback_t)dir_scan_callback_func_exall);
4001
4002         SHOWVALUE(count);
4003
4004         if(count == 0 || eac->eac_Entries == 0)
4005         {
4006                 SHOWMSG("nothing to be read");
4007                 if(ec.ec_Error != OK)
4008                 {
4009                         SHOWMSG("flagging an error");
4010                         SHOWVALUE(ec.ec_Error);
4011                         eac->eac_LastKey = (ULONG)-1;
4012                         error = ec.ec_Error;
4013                 }
4014
4015                 goto out;
4016         }
4017         else if (count == (-EIO))
4018         {
4019                 SHOWMSG("ouch! directory read error");
4020                 eac->eac_LastKey = (ULONG)-1;
4021
4022                 error = ERROR_NO_DEFAULT_DIR;
4023                 goto out;
4024         }
4025         else if (count < 0)
4026         {
4027                 SHOWMSG("error whilst scanning");
4028                 eac->eac_LastKey = (ULONG)-1;
4029
4030                 error = MapErrnoToIoErr(count);
4031                 goto out;
4032         }
4033
4034         SHOWMSG("ok");
4035         result = DOSTRUE;
4036
4037  out:
4038
4039         #if DEBUG
4040         {
4041                 SHOWVALUE(eac->eac_Entries);
4042
4043                 while(ed != NULL)
4044                 {
4045                         SHOWSTRING(ed->ed_Name);
4046
4047                         ed = ed->ed_Next;
4048                 }
4049         }
4050         #endif /* DEBUG */
4051
4052         (*error_ptr) = error;
4053
4054         RETURN(result);
4055         return(result);
4056 }
4057
4058 /****************************************************************************/
4059
4060 STATIC LONG
4061 Action_Find(
4062         LONG                                    action,
4063         struct FileHandle *             fh,
4064         struct FileLock *               parent,
4065         APTR                                    bcpl_name,
4066         SIPTR *                                 error_ptr)
4067 {
4068         LONG result = DOSFALSE;
4069         STRPTR parent_path = NULL;
4070         STRPTR full_name = NULL;
4071         LONG full_name_size;
4072         struct FileNode * fn = NULL;
4073         STRPTR parent_name;
4074         UBYTE name[MAX_FILENAME_LEN];
4075         BOOL file_exists = FALSE;
4076         BOOL create_new_file;
4077         smba_file_t * file = NULL;
4078         smba_stat_t st;
4079         LONG error;
4080
4081         ENTER();
4082
4083         switch(action)
4084         {
4085                 case ACTION_FINDINPUT:
4086                         D(("ACTION_FINDINPUT [Open(\"%b\",MODE_OLDFILE)]",MKBADDR(bcpl_name)));
4087                         break;
4088
4089                 case ACTION_FINDOUTPUT:
4090                         D(("ACTION_FINDOUTPUT [Open(\"%b\",MODE_NEWFILE)]",MKBADDR(bcpl_name)));
4091                         break;
4092
4093                 case ACTION_FINDUPDATE:
4094                         D(("ACTION_FINDUPDATE [Open(\"%b\",MODE_READWRITE)]",MKBADDR(bcpl_name)));
4095                         break;
4096         }
4097
4098         SHOWVALUE(parent);
4099
4100         if(parent != NULL)
4101         {
4102                 struct LockNode * ln = (struct LockNode *)parent->fl_Key;
4103
4104                 parent_name = ln->ln_FullName;
4105         }
4106         else
4107         {
4108                 parent_name = NULL;
4109         }
4110
4111         ConvertBString(sizeof(name),name,bcpl_name);
4112         TranslateCName(name,A2M);
4113
4114         if(IsReservedName(FilePart(name)))
4115         {
4116                 error = ERROR_OBJECT_NOT_FOUND;
4117                 goto out;
4118         }
4119
4120         error = BuildFullName(parent_name,name,&full_name,&full_name_size);
4121         if(error != OK)
4122                 goto out;
4123
4124         /* Trying to open the root directory? */
4125         if(full_name == NULL)
4126         {
4127                 error = ERROR_OBJECT_WRONG_TYPE;
4128                 goto out;
4129         }
4130
4131         fn = AllocateMemory(sizeof(*fn));
4132         if(fn == NULL)
4133         {
4134                 error = ERROR_NO_FREE_STORE;
4135                 goto out;
4136         }
4137
4138         memset(fn,0,sizeof(*fn));
4139
4140         fn->fn_Handle   = fh;
4141         fn->fn_FullName = full_name;
4142         fn->fn_Mode             = (action == ACTION_FINDOUTPUT) ? EXCLUSIVE_LOCK : SHARED_LOCK;
4143
4144         error = CheckAccessModeCollision(full_name,fn->fn_Mode);
4145         if(error != OK)
4146                 goto out;
4147
4148         SHOWSTRING(full_name);
4149
4150         if(smba_open(ServerData,full_name,full_name_size,&file) == OK &&
4151            smba_getattr(file,&st) == OK)
4152         {
4153                 file_exists = TRUE;
4154                 if(st.is_dir)
4155                 {
4156                         error = ERROR_OBJECT_WRONG_TYPE;
4157                         goto out;
4158                 }
4159         }
4160         if(file != NULL)
4161                 smba_close(file);
4162
4163         if(action == ACTION_FINDOUTPUT)
4164         {
4165                 /* Definitely create a new file. */
4166                 create_new_file = TRUE;
4167         }
4168         else if (action == ACTION_FINDINPUT)
4169         {
4170                 /* Open an existing file for reading. */
4171                 create_new_file = FALSE;
4172         }
4173         else if (action == ACTION_FINDUPDATE)
4174         {
4175                 if(file_exists)
4176                 {
4177                         /* File apparently opens Ok and information on it
4178                          * is available, don't try to replace it.
4179                          */
4180                         create_new_file = FALSE;
4181                 }
4182                 else
4183                 {
4184                         /* We try to ignore the error here and assume
4185                          * that the remainder of the file opening
4186                          * procedure will produce a useful error
4187                          * report. In the mean time, assume that the
4188                          * file needs to be created.
4189                          */
4190                         create_new_file = TRUE;
4191                 }
4192         }
4193         else
4194         {
4195                 /* What's that? */
4196                 error = ERROR_ACTION_NOT_KNOWN;
4197                 goto out;
4198         }
4199
4200         /* Create a new file? */
4201         if(create_new_file)
4202         {
4203                 smba_file_t * dir;
4204                 STRPTR base_name;
4205                 LONG i;
4206
4207                 if(WriteProtected)
4208                 {
4209                         error = ERROR_DISK_WRITE_PROTECTED;
4210                         goto out;
4211                 }
4212
4213                 parent_path = AllocateMemory(strlen(full_name)+3);
4214                 if(parent_path == NULL)
4215                 {
4216                         error = ERROR_NO_FREE_STORE;
4217                         goto out;
4218                 }
4219
4220                 strcpy(parent_path,full_name);
4221                 base_name = NULL;
4222                 for(i = strlen(parent_path)-1 ; i >= 0 ; i--)
4223                 {
4224                         if(parent_path[i] == SMB_PATH_SEPARATOR)
4225                         {
4226                                 if(i == 0)
4227                                 {
4228                                         memmove(&parent_path[1],&parent_path[0],strlen(parent_path)+1);
4229                                         i++;
4230                                 }
4231
4232                                 parent_path[i] = '\0';
4233
4234                                 base_name = &parent_path[i+1];
4235                                 break;
4236                         }
4237                 }
4238
4239                 SHOWMSG("creating a file; finding parent path first");
4240                 SHOWSTRING(parent_path);
4241
4242                 error = smba_open(ServerData,parent_path,strlen(full_name)+3,&dir);
4243                 if(error < 0)
4244                 {
4245                         error = MapErrnoToIoErr(error);
4246                         goto out;
4247                 }
4248
4249                 /* Only one attribute counts: the file should not be write protected. */
4250                 memset(&st,0,sizeof(st));
4251
4252                 SHOWMSG("now trying to create the file");
4253                 SHOWSTRING(base_name);
4254
4255                 error = smba_create(dir,base_name,&st);
4256                 if(error < 0)
4257                 {
4258                         SHOWMSG("didn't work.");
4259                         SHOWVALUE(error);
4260
4261                         smba_close(dir);
4262                         error = MapErrnoToIoErr(error);
4263
4264                         SHOWVALUE(error);
4265
4266                         goto out;
4267                 }
4268
4269                 SHOWMSG("good.");
4270
4271                 smba_close(dir);
4272         }
4273
4274         /* Now for the remainder... */
4275         error = smba_open(ServerData,full_name,full_name_size,&fn->fn_File);
4276         if(error < 0)
4277         {
4278                 error = MapErrnoToIoErr(error);
4279                 goto out;
4280         }
4281
4282         fh->fh_Arg1 = (IPTR)fn;
4283
4284         AddTail((struct List *)&FileList,(struct Node *)fn);
4285         result = DOSTRUE;
4286
4287  out:
4288
4289         if(result == DOSFALSE)
4290         {
4291                 FreeMemory(full_name);
4292                 FreeMemory(fn);
4293         }
4294
4295         FreeMemory(parent_path);
4296
4297         (*error_ptr) = error;
4298
4299         RETURN(result);
4300         return(result);
4301 }
4302
4303 /****************************************************************************/
4304
4305 STATIC LONG
4306 Action_Read(
4307         struct FileNode *       fn,
4308         APTR                            mem,
4309         LONG                            length,
4310         SIPTR *                         error_ptr)
4311 {
4312         LONG result = 0;
4313         LONG error = OK;
4314
4315         ENTER();
4316
4317         if(length > 0)
4318         {
4319                 result = smba_read(fn->fn_File,mem,length,fn->fn_Offset);
4320                 if(result < 0)
4321                 {
4322                         error = MapErrnoToIoErr(result);
4323                         result = -1;
4324                         goto out;
4325                 }
4326
4327                 fn->fn_Offset += result;
4328         }
4329
4330  out:
4331
4332         (*error_ptr) = error;
4333
4334         RETURN(result);
4335         return(result);
4336 }
4337
4338 /****************************************************************************/
4339
4340 STATIC LONG
4341 Action_Write(
4342         struct FileNode *       fn,
4343         APTR                            mem,
4344         LONG                            length,
4345         SIPTR *                         error_ptr)
4346 {
4347         LONG result = DOSFALSE;
4348         LONG error = OK;
4349
4350         ENTER();
4351
4352         if(WriteProtected)
4353         {
4354                 error = ERROR_DISK_WRITE_PROTECTED;
4355                 goto out;
4356         }
4357
4358         if(length > 0)
4359         {
4360                 result = smba_write(fn->fn_File,mem,length,fn->fn_Offset);
4361                 if(result < 0)
4362                 {
4363                         error = MapErrnoToIoErr(result);
4364                         result = -1;
4365                         goto out;
4366                 }
4367
4368                 fn->fn_Offset += result;
4369         }
4370
4371  out:
4372
4373         (*error_ptr) = error;
4374
4375         RETURN(result);
4376         return(result);
4377 }
4378
4379 /****************************************************************************/
4380
4381 STATIC LONG
4382 Action_End(
4383         struct FileNode *       fn,
4384         SIPTR *                         error_ptr)
4385 {
4386         Remove((struct Node *)fn);
4387
4388         smba_close(fn->fn_File);
4389         FreeMemory(fn->fn_FullName);
4390         FreeMemory(fn);
4391
4392         (*error_ptr) = OK;
4393         return(DOSTRUE);
4394 }
4395
4396 /****************************************************************************/
4397
4398 STATIC LONG
4399 Action_Seek(
4400         struct FileNode *       fn,
4401         LONG                            position,
4402         LONG                            mode,
4403         SIPTR *                         error_ptr)
4404 {
4405         LONG previous_position = fn->fn_Offset;
4406         LONG result = -1;
4407         LONG offset;
4408         LONG error;
4409
4410         ENTER();
4411
4412         /* olsen: This doesn't really work with Microsoft SMB servers, but it works with Samba. */
4413         #if 0
4414         {
4415                 switch(mode)
4416                 {
4417                         case OFFSET_BEGINNING:
4418
4419                                 mode = 0;
4420                                 break;
4421
4422                         case OFFSET_CURRENT:
4423
4424                                 mode = 1;
4425                                 break;
4426
4427                         case OFFSET_END:
4428
4429                                 mode = 2;
4430                                 break;
4431
4432                         default:
4433
4434                                 error = ERROR_ACTION_NOT_KNOWN;
4435                                 goto out;
4436                 }
4437
4438                 error = smba_seek (fn->fn_File, position, mode, (off_t *) &offset);
4439                 if(error < 0)
4440                 {
4441                         error = MapErrnoToIoErr(error);
4442                         goto out;
4443                 }
4444         }
4445         #endif
4446
4447         /* olsen: This is the original implementation. */
4448         #if 0
4449         {
4450                 smba_stat_t st;
4451
4452                 error = smba_getattr(fn->fn_File,&st);
4453                 if(error < 0)
4454                 {
4455                         error = MapErrnoToIoErr(error);
4456                         goto out;
4457                 }
4458
4459                 offset = fn->fn_Offset;
4460
4461                 switch(mode)
4462                 {
4463                         case OFFSET_BEGINNING:
4464
4465                                 offset = position;
4466                                 break;
4467
4468                         case OFFSET_CURRENT:
4469
4470                                 offset += position;
4471                                 break;
4472
4473                         case OFFSET_END:
4474
4475                                 offset = st.size + position;
4476                                 break;
4477
4478                         default:
4479
4480                                 error = ERROR_ACTION_NOT_KNOWN;
4481                                 goto out;
4482                 }
4483
4484                 if(offset < 0 || offset > st.size)
4485                 {
4486                         error = ERROR_SEEK_ERROR;
4487                         goto out;
4488                 }
4489         }
4490         #endif
4491
4492         /* olsen: This is a mix of the two above. First we calculate the absolute
4493          *        position, then seek to that position. The SMB server is supposed
4494          *        to do its housekeeping before the position is changed. I wish this
4495          *        worked differently, but it seems we've got the best of both worlds
4496          *        here...
4497          */
4498         #if 1
4499         {
4500                 smba_stat_t st;
4501
4502                 switch(mode)
4503                 {
4504                         case OFFSET_BEGINNING:
4505
4506                                 offset = position;
4507                                 break;
4508
4509                         case OFFSET_CURRENT:
4510
4511                                 offset = fn->fn_Offset + position;
4512                                 break;
4513
4514                         case OFFSET_END:
4515
4516                                 error = smba_getattr(fn->fn_File,&st);
4517                                 if(error < 0)
4518                                 {
4519                                         error = MapErrnoToIoErr(error);
4520                                         goto out;
4521                                 }
4522
4523                                 offset = st.size + position;
4524                                 break;
4525
4526                         default:
4527
4528                                 error = ERROR_ACTION_NOT_KNOWN;
4529                                 goto out;
4530                 }
4531
4532                 if(offset < 0)
4533                 {
4534                         error = ERROR_SEEK_ERROR;
4535                         goto out;
4536                 }
4537
4538                 error = smba_seek (fn->fn_File, offset, 0, (off_t *) &offset);
4539                 if(error < 0)
4540                 {
4541                         error = MapErrnoToIoErr(error);
4542                         goto out;
4543                 }
4544         }
4545         #endif
4546
4547         error = OK;
4548
4549         fn->fn_Offset = offset;
4550
4551         result = previous_position;
4552
4553  out:
4554
4555         (*error_ptr) = error;
4556
4557         RETURN(result);
4558         return(result);
4559 }
4560
4561 /****************************************************************************/
4562
4563 STATIC LONG
4564 Action_SetFileSize(
4565         struct FileNode *       fn,
4566         LONG                            position,
4567         LONG                            mode,
4568         SIPTR *                         error_ptr)
4569 {
4570         smba_stat_t st;
4571         LONG result = -1;
4572         LONG error;
4573         long offset;
4574
4575         ENTER();
4576
4577         if(WriteProtected)
4578         {
4579                 error = ERROR_DISK_WRITE_PROTECTED;
4580                 goto out;
4581         }
4582
4583         error = smba_getattr(fn->fn_File,&st);
4584         if(error < 0)
4585         {
4586                 error = MapErrnoToIoErr(error);
4587                 goto out;
4588         }
4589
4590         offset = fn->fn_Offset;
4591
4592         switch(mode)
4593         {
4594                 case OFFSET_BEGINNING:
4595
4596                         offset = position;
4597                         break;
4598
4599                 case OFFSET_CURRENT:
4600
4601                         offset += position;
4602                         break;
4603
4604                 case OFFSET_END:
4605
4606                         offset = st.size + position;
4607                         break;
4608
4609                 default:
4610
4611                         error = ERROR_ACTION_NOT_KNOWN;
4612                         goto out;
4613         }
4614
4615         if(offset < 0)
4616         {
4617                 error = ERROR_SEEK_ERROR;
4618                 goto out;
4619         }
4620
4621         st.atime        = -1;
4622         st.ctime        = -1;
4623         st.mtime        = -1;
4624         st.size         = offset;
4625
4626         error = smba_setattr(fn->fn_File,&st);
4627         if(error < 0)
4628         {
4629                 error = MapErrnoToIoErr(error);
4630                 goto out;
4631         }
4632
4633         if(fn->fn_Offset > offset)
4634                 fn->fn_Offset = offset;
4635
4636         result = offset;
4637
4638  out:
4639
4640         (*error_ptr) = error;
4641
4642         RETURN(result);
4643         return(result);
4644 }
4645
4646 /****************************************************************************/
4647
4648 STATIC LONG
4649 Action_SetDate(
4650         struct FileLock *       parent,
4651         APTR                            bcpl_name,
4652         struct DateStamp *      ds,
4653         SIPTR *                         error_ptr)
4654 {
4655         LONG result = DOSFALSE;
4656         STRPTR full_name = NULL;
4657         LONG full_name_size;
4658         smba_file_t * file = NULL;
4659         STRPTR parent_name;
4660         UBYTE name[MAX_FILENAME_LEN];
4661         smba_stat_t st;
4662         LONG seconds;
4663         LONG error;
4664
4665         ENTER();
4666
4667         if(WriteProtected)
4668         {
4669                 error = ERROR_DISK_WRITE_PROTECTED;
4670                 goto out;
4671         }
4672
4673         SHOWVALUE(parent);
4674
4675         if(parent != NULL)
4676         {
4677                 struct LockNode * ln = (struct LockNode *)parent->fl_Key;
4678
4679                 parent_name = ln->ln_FullName;
4680         }
4681         else
4682         {
4683                 parent_name = NULL;
4684         }
4685
4686         ConvertBString(sizeof(name),name,bcpl_name);
4687         TranslateCName(name,A2M);
4688
4689         error = BuildFullName(parent_name,name,&full_name,&full_name_size);
4690         if(error != OK)
4691                 goto out;
4692
4693         /* Trying to change the date of the root directory? */
4694         if(full_name == NULL)
4695         {
4696                 error = ERROR_OBJECT_IN_USE;
4697                 goto out;
4698         }
4699
4700         SHOWSTRING(full_name);
4701
4702         error = smba_open(ServerData,full_name,full_name_size,&file);
4703         if(error < 0)
4704         {
4705                 error = MapErrnoToIoErr(error);
4706                 goto out;
4707         }
4708
4709         error = smba_getattr(file,&st);
4710         if(error < 0)
4711         {
4712                 error = MapErrnoToIoErr(error);
4713                 goto out;
4714         }
4715
4716         seconds = (ds->ds_Days * 24 * 60 + ds->ds_Minute) * 60 + (ds->ds_Tick / TICKS_PER_SECOND);
4717
4718         st.atime = -1;
4719         st.ctime = -1;
4720         st.mtime = seconds + UNIX_TIME_OFFSET + GetTimeZoneDelta();
4721         st.size = -1;
4722
4723         error = smba_setattr(file,&st);
4724         if(error < 0)
4725         {
4726                 error = MapErrnoToIoErr(error);
4727                 goto out;
4728         }
4729
4730         result = DOSTRUE;
4731
4732  out:
4733
4734         FreeMemory(full_name);
4735         if(file != NULL)
4736                 smba_close(file);
4737
4738         (*error_ptr) = error;
4739
4740         RETURN(result);
4741         return(result);
4742 }
4743
4744 /****************************************************************************/
4745
4746 STATIC LONG
4747 Action_ExamineFH(
4748         struct FileNode *               fn,
4749         struct FileInfoBlock *  fib,
4750         SIPTR *                                 error_ptr)
4751 {
4752         LONG result = DOSFALSE;
4753         smba_stat_t st;
4754         LONG error;
4755         LONG seconds;
4756         STRPTR name;
4757         LONG i;
4758
4759         ENTER();
4760
4761         error = smba_getattr(fn->fn_File,&st);
4762         if(error < 0)
4763         {
4764                 error = MapErrnoToIoErr(error);
4765                 goto out;
4766         }
4767
4768         name = fn->fn_FullName;
4769         for(i = strlen(name)-1 ; i >= 0 ; i--)
4770         {
4771                 if(name[i] == SMB_PATH_SEPARATOR)
4772                 {
4773                         name = &name[i+1];
4774                         break;
4775                 }
4776         }
4777
4778         /* Just checking: will the name fit? */
4779         if(strlen(name) >= sizeof(fib->fib_FileName))
4780         {
4781                 error = ERROR_INVALID_COMPONENT_NAME;
4782                 goto out;
4783         }
4784
4785         memset(fib,0,sizeof(*fib));
4786
4787         ConvertCString(sizeof(fib->fib_FileName),fib->fib_FileName,name);
4788         TranslateBName(fib->fib_FileName,M2A);
4789
4790         fib->fib_DirEntryType   = ST_FILE;
4791         fib->fib_EntryType              = ST_FILE;
4792         fib->fib_NumBlocks              = (st.size + 511) / 512;
4793         fib->fib_Size                   = st.size;
4794         fib->fib_DiskKey                = -1;
4795
4796         fib->fib_Protection             = FIBF_OTR_READ|FIBF_OTR_EXECUTE|FIBF_OTR_WRITE|FIBF_OTR_DELETE|
4797                                                           FIBF_GRP_READ|FIBF_GRP_EXECUTE|FIBF_GRP_WRITE|FIBF_GRP_DELETE;
4798
4799         if(st.is_wp)
4800                 fib->fib_Protection ^= (FIBF_OTR_WRITE|FIBF_OTR_DELETE|FIBF_GRP_WRITE|FIBF_GRP_DELETE|FIBF_WRITE|FIBF_DELETE);
4801
4802         /* Careful: the 'archive' attribute has exactly the opposite
4803          *          meaning in the Amiga and the SMB worlds.
4804          */
4805         if(NOT st.is_archive)
4806                 fib->fib_Protection |= FIBF_ARCHIVE;
4807
4808         if(st.is_system)
4809                 fib->fib_Protection |= FIBF_PURE;
4810
4811         seconds = st.mtime - UNIX_TIME_OFFSET - GetTimeZoneDelta();
4812         if(seconds < 0)
4813                 seconds = 0;
4814
4815         fib->fib_Date.ds_Days   = (seconds / (24 * 60 * 60));
4816         fib->fib_Date.ds_Minute = (seconds % (24 * 60 * 60)) / 60;
4817         fib->fib_Date.ds_Tick   = (seconds % 60) * TICKS_PER_SECOND;
4818
4819         result = DOSTRUE;
4820
4821  out:
4822
4823         (*error_ptr) = error;
4824
4825         RETURN(result);
4826         return(result);
4827 }
4828
4829 /****************************************************************************/
4830
4831 STATIC BPTR
4832 Action_ParentFH(
4833         struct FileNode *       fn,
4834         SIPTR *                         error_ptr)
4835 {
4836         BPTR result = ZERO;
4837         struct LockNode * ln = NULL;
4838         LONG error;
4839         STRPTR full_name;
4840         LONG full_name_size;
4841         LONG i;
4842
4843         ENTER();
4844
4845         full_name_size = strlen(fn->fn_FullName)+3;
4846         if(full_name_size < SMB_MAXNAMELEN+1)
4847                 full_name_size = SMB_MAXNAMELEN+1;
4848
4849         full_name = AllocateMemory(full_name_size);
4850         if(full_name == NULL)
4851         {
4852                 error = ERROR_NO_FREE_STORE;
4853                 goto out;
4854         }
4855
4856         strcpy(full_name,fn->fn_FullName);
4857
4858         for(i = strlen(full_name)-1 ; i >= 0 ; i--)
4859         {
4860                 if(i == 0)
4861                 {
4862                         strcpy(full_name,SMB_ROOT_DIR_NAME);
4863                         break;
4864                 }
4865                 else if (full_name[i] == SMB_PATH_SEPARATOR)
4866                 {
4867                         full_name[i] = '\0';
4868                         break;
4869                 }
4870         }
4871
4872         ln = AllocateMemory(sizeof(*ln));
4873         if(ln == NULL)
4874         {
4875                 error = ERROR_NO_FREE_STORE;
4876                 goto out;
4877         }
4878
4879         memset(ln,0,sizeof(*ln));
4880
4881         ln->ln_FileLock.fl_Key          = (IPTR)ln;
4882         ln->ln_FileLock.fl_Access       = SHARED_LOCK;
4883         ln->ln_FileLock.fl_Task         = FileSystemPort;
4884         ln->ln_FileLock.fl_Volume       = MKBADDR(VolumeNode);
4885         ln->ln_FullName                         = full_name;
4886
4887         SHOWSTRING(full_name);
4888
4889         error = smba_open(ServerData,full_name,full_name_size,&ln->ln_File);
4890         if(error < 0)
4891         {
4892                 error = MapErrnoToIoErr(error);
4893                 goto out;
4894         }
4895
4896         AddTail((struct List *)&LockList,(struct Node *)ln);
4897         result = MKBADDR(&ln->ln_FileLock);
4898         SHOWVALUE(&ln->ln_FileLock);
4899
4900  out:
4901
4902         if(result == ZERO)
4903         {
4904                 FreeMemory(ln);
4905                 FreeMemory(full_name);
4906         }
4907
4908         (*error_ptr) = error;
4909
4910         RETURN(result);
4911         return(result);
4912 }
4913
4914 /****************************************************************************/
4915
4916 STATIC BPTR
4917 Action_CopyDirFH(
4918         struct FileNode *       fn,
4919         SIPTR *                         error_ptr)
4920 {
4921         BPTR result = ZERO;
4922         struct LockNode * ln = NULL;
4923         STRPTR full_name = NULL;
4924         LONG full_name_size;
4925         LONG error;
4926
4927         ENTER();
4928
4929         if(fn->fn_Mode != SHARED_LOCK)
4930         {
4931                 error = ERROR_OBJECT_IN_USE;
4932                 goto out;
4933         }
4934
4935         full_name_size = strlen(fn->fn_FullName)+3;
4936         if(full_name_size < SMB_MAXNAMELEN+1)
4937                 full_name_size = SMB_MAXNAMELEN+1;
4938
4939         full_name = AllocateMemory(full_name_size);
4940         if(full_name == NULL)
4941         {
4942                 error = ERROR_NO_FREE_STORE;
4943                 goto out;
4944         }
4945
4946         strcpy(full_name,fn->fn_FullName);
4947
4948         ln = AllocateMemory(sizeof(*ln));
4949         if(ln == NULL)
4950         {
4951                 error = ERROR_NO_FREE_STORE;
4952                 goto out;
4953         }
4954
4955         memset(ln,0,sizeof(*ln));
4956
4957         ln->ln_FileLock.fl_Key          = (IPTR)ln;
4958         ln->ln_FileLock.fl_Access       = SHARED_LOCK;
4959         ln->ln_FileLock.fl_Task         = FileSystemPort;
4960         ln->ln_FileLock.fl_Volume       = MKBADDR(VolumeNode);
4961         ln->ln_FullName                         = full_name;
4962
4963         SHOWSTRING(full_name);
4964
4965         error = smba_open(ServerData,full_name,full_name_size,&ln->ln_File);
4966         if(error < 0)
4967         {
4968                 error = MapErrnoToIoErr(error);
4969                 goto out;
4970         }
4971
4972         AddTail((struct List *)&LockList,(struct Node *)ln);
4973         result = MKBADDR(&ln->ln_FileLock);
4974         SHOWVALUE(&ln->ln_FileLock);
4975
4976  out:
4977
4978         if(result == ZERO)
4979         {
4980                 FreeMemory(ln);
4981                 FreeMemory(full_name);
4982         }
4983
4984         (*error_ptr) = error;
4985
4986         RETURN(result);
4987         return(result);
4988 }
4989
4990 /****************************************************************************/
4991
4992 STATIC LONG
4993 Action_FHFromLock(
4994         struct FileHandle *     fh,
4995         struct FileLock *       fl,
4996         SIPTR *                         error_ptr)
4997 {
4998         LONG result = DOSFALSE;
4999         struct FileNode * fn;
5000         struct LockNode * ln;
5001         LONG error = OK;
5002
5003         ENTER();
5004
5005         SHOWVALUE(fl);
5006
5007         fn = AllocateMemory(sizeof(*fn));
5008         if(fn == NULL)
5009         {
5010                 error = ERROR_NO_FREE_STORE;
5011                 goto out;
5012         }
5013
5014         memset(fn,0,sizeof(*fn));
5015
5016         ln = (struct LockNode *)fl->fl_Key;
5017
5018         fn->fn_Handle   = fh;
5019         fn->fn_FullName = ln->ln_FullName;
5020         fn->fn_File             = ln->ln_File;
5021         fn->fn_Mode             = fl->fl_Access;
5022
5023         Remove((struct Node *)ln);
5024         FreeMemory(ln);
5025
5026         fh->fh_Arg1 = (IPTR)fn;
5027
5028         AddTail((struct List *)&FileList,(struct Node *)fn);
5029         result = DOSTRUE;
5030
5031  out:
5032
5033         (*error_ptr) = error;
5034
5035         RETURN(result);
5036         return(result);
5037 }
5038
5039 /****************************************************************************/
5040
5041 STATIC LONG
5042 Action_RenameDisk(
5043         APTR    bcpl_name,
5044         SIPTR * error_ptr)
5045 {
5046         LONG result = DOSFALSE;
5047         LONG error = OK;
5048         STRPTR old_name;
5049         STRPTR new_name;
5050         UBYTE * name;
5051         LONG len;
5052
5053         ENTER();
5054
5055         if(NOT VolumeNodeAdded)
5056         {
5057                 error = ERROR_OBJECT_IN_USE;
5058                 goto out;
5059         }
5060
5061         if(WriteProtected)
5062         {
5063                 error = ERROR_DISK_WRITE_PROTECTED;
5064                 goto out;
5065         }
5066
5067         /* Now for the really interesting part; the new name
5068          * is to be a NUL-terminated BCPL string, and as such
5069          * must be allocated via AllocVec().
5070          */
5071
5072         name = bcpl_name;
5073
5074         len = name[0];
5075
5076         new_name = AllocVec(1 + len + 1,MEMF_ANY|MEMF_PUBLIC);
5077         if(new_name == NULL)
5078         {
5079                 error = ERROR_NO_FREE_STORE;
5080                 goto out;
5081         }
5082
5083         new_name[0] = len;
5084         memcpy(&new_name[1],&name[1],len);
5085         new_name[len+1] = '\0';
5086
5087         Forbid();
5088
5089         old_name = BADDR(VolumeNode->dol_Name);
5090         VolumeNode->dol_Name = MKBADDR(new_name);
5091
5092         Permit();
5093
5094         FreeVec(old_name);
5095
5096         SendDiskChange(IECLASS_DISKINSERTED);
5097
5098         result = DOSTRUE;
5099
5100  out:
5101
5102         (*error_ptr) = error;
5103
5104         RETURN(result);
5105         return(result);
5106 }
5107
5108 /****************************************************************************/
5109
5110 STATIC LONG
5111 Action_ChangeMode(
5112         LONG                            type,
5113         APTR                            object,
5114         LONG                            new_mode,
5115         SIPTR *                         error_ptr)
5116 {
5117         LONG result = DOSFALSE;
5118         struct FileLock * fl = NULL;
5119         struct FileNode * fn = NULL;
5120         struct LockNode * ln = NULL;
5121         STRPTR name;
5122         LONG old_mode;
5123         LONG error = OK;
5124
5125         ENTER();
5126
5127         /* Sanity check; verify parameters */
5128         if((type != CHANGE_LOCK && type != CHANGE_FH) ||
5129            (new_mode != EXCLUSIVE_LOCK && new_mode != SHARED_LOCK))
5130         {
5131                 error = ERROR_ACTION_NOT_KNOWN;
5132                 goto out;
5133         }
5134
5135         /* Now obtain the data structures, name and mode
5136          * associated with the object in question.
5137          */
5138         if(type == CHANGE_LOCK)
5139         {
5140                 fl = object;
5141                 ln = (struct LockNode *)fl->fl_Key;
5142                 name = ln->ln_FullName;
5143                 old_mode = fl->fl_Access;
5144         }
5145         else
5146         {
5147                 struct FileHandle * fh = object;
5148
5149                 fn = (struct FileNode *)fh->fh_Arg1;
5150                 name = fn->fn_FullName;
5151                 old_mode = fn->fn_Mode;
5152         }
5153
5154         /* Do we need to change anything at all? */
5155         if(new_mode == old_mode)
5156         {
5157                 result = DOSTRUE;
5158                 goto out;
5159         }
5160
5161         /* This is the easiest case; change an
5162          * exclusive access mode to a shared
5163          * access mode. Since the original mode
5164          * can be used by one object only,
5165          * we get away by updating the mode
5166          * value.
5167          */
5168         if(new_mode == SHARED_LOCK)
5169         {
5170                 if(type == CHANGE_LOCK)
5171                         fl->fl_Access = new_mode;
5172                 else
5173                         fn->fn_Mode = new_mode;
5174
5175                 result = DOSTRUE;
5176                 goto out;
5177         }
5178
5179         /* Is there another shared access lock
5180          * which refers to the same object?
5181          */
5182         if(FindLockNode(name,ln) != NULL)
5183         {
5184                 error = ERROR_OBJECT_IN_USE;
5185                 goto out;
5186         }
5187
5188         /* Is there another shared access file
5189          * which refers to the same object?
5190          */
5191         if(FindFileNode(name,fn) != NULL)
5192         {
5193                 error = ERROR_OBJECT_IN_USE;
5194                 goto out;
5195         }
5196
5197         /* There is just one single reference
5198          * to this object; change the mode
5199          * and quit.
5200          */
5201         if(type == CHANGE_LOCK)
5202                 fl->fl_Access = new_mode;
5203         else
5204                 fn->fn_Mode = new_mode;
5205
5206         result = DOSTRUE;
5207
5208  out:
5209
5210         (*error_ptr) = error;
5211
5212         RETURN(result);
5213         return(result);
5214 }
5215
5216 /****************************************************************************/
5217
5218 STATIC LONG
5219 Action_WriteProtect(
5220         LONG    flag,
5221         ULONG   key,
5222         SIPTR * error_ptr)
5223 {
5224         LONG result = DOSFALSE;
5225         LONG error = OK;
5226
5227         ENTER();
5228
5229         if(flag == DOSFALSE)
5230         {
5231                 if(WriteProtected)
5232                 {
5233                         if(key != WriteProtectKey)
5234                         {
5235                                 error = ERROR_INVALID_LOCK;
5236                                 goto out;
5237                         }
5238
5239                         WriteProtected = FALSE;
5240
5241                         if(VolumeNodeAdded)
5242                         {
5243                                 SendDiskChange(IECLASS_DISKREMOVED);
5244                                 SendDiskChange(IECLASS_DISKINSERTED);
5245                         }
5246                 }
5247         }
5248         else
5249         {
5250                 if(NOT WriteProtected)
5251                 {
5252                         WriteProtected = TRUE;
5253                         WriteProtectKey = key;
5254
5255                         if(VolumeNodeAdded)
5256                         {
5257                                 SendDiskChange(IECLASS_DISKREMOVED);
5258                                 SendDiskChange(IECLASS_DISKINSERTED);
5259                         }
5260                 }
5261                 else
5262                 {
5263                         error = ERROR_INVALID_LOCK;
5264                         goto out;
5265                 }
5266         }
5267
5268         result = DOSTRUE;
5269
5270  out:
5271
5272         (*error_ptr) = error;
5273
5274         RETURN(result);
5275         return(result);
5276 }
5277
5278 /****************************************************************************/
5279
5280 STATIC LONG
5281 Action_MoreCache(
5282         LONG    buffer_delta,
5283         SIPTR * error_ptr)
5284 {
5285         LONG result;
5286         int old_size;
5287
5288         ENTER();
5289
5290         old_size = smba_get_dircache_size(ServerData);
5291
5292         result = smba_change_dircache_size(ServerData,old_size + buffer_delta);
5293
5294         if(result == old_size && buffer_delta != 0)
5295         {
5296                 result = DOSFALSE;
5297                 (*error_ptr) = ERROR_NO_FREE_STORE;
5298         }
5299
5300         RETURN(result);
5301         return(result);
5302 }
5303
5304 /****************************************************************************/
5305
5306 STATIC LONG
5307 Action_SetComment(
5308         struct FileLock *       parent,
5309         APTR                            bcpl_name,
5310         APTR                            bcpl_comment,
5311         SIPTR *                         error_ptr)
5312 {
5313         LONG result = DOSFALSE;
5314         STRPTR full_name = NULL;
5315         LONG full_name_size;
5316         smba_file_t * file = NULL;
5317         STRPTR parent_name;
5318         UBYTE name[MAX_FILENAME_LEN];
5319         UBYTE comment[80];
5320         LONG error;
5321
5322         ENTER();
5323
5324         if(WriteProtected)
5325         {
5326                 error = ERROR_DISK_WRITE_PROTECTED;
5327                 goto out;
5328         }
5329
5330         SHOWVALUE(parent);
5331
5332         if(parent != NULL)
5333         {
5334                 struct LockNode * ln = (struct LockNode *)parent->fl_Key;
5335
5336                 parent_name = ln->ln_FullName;
5337         }
5338         else
5339         {
5340                 parent_name = NULL;
5341         }
5342
5343         ConvertBString(sizeof(name),name,bcpl_name);
5344         TranslateCName(name,A2M);
5345
5346         error = BuildFullName(parent_name,name,&full_name,&full_name_size);
5347         if(error != OK)
5348                 goto out;
5349
5350         /* Trying to change the comment of the root directory? */
5351         if(full_name == NULL)
5352         {
5353                 error = ERROR_OBJECT_IN_USE;
5354                 goto out;
5355         }
5356
5357         SHOWSTRING(full_name);
5358
5359         error = smba_open(ServerData,full_name,full_name_size,&file);
5360         if(error < 0)
5361         {
5362                 error = MapErrnoToIoErr(error);
5363                 goto out;
5364         }
5365
5366         ConvertBString(sizeof(comment),comment,bcpl_comment);
5367
5368         SHOWSTRING(comment);
5369
5370         /* All this work and we're only doing something very silly... */
5371         if(strlen(comment) > 0)
5372         {
5373                 error = ERROR_COMMENT_TOO_BIG;
5374                 goto out;
5375         }
5376
5377         result = DOSTRUE;
5378
5379  out:
5380
5381         FreeMemory(full_name);
5382         if(file != NULL)
5383                 smba_close(file);
5384
5385         (*error_ptr) = error;
5386
5387         RETURN(result);
5388         return(result);
5389 }
5390
5391 /****************************************************************************/
5392
5393 STATIC LONG
5394 Action_LockRecord (
5395         struct FileNode *       fn,
5396         LONG                            offset,
5397         LONG                            length,
5398         LONG                            mode,
5399         ULONG                           timeout,
5400         SIPTR *                         error_ptr)
5401 {
5402         LONG result = DOSFALSE;
5403         LONG error;
5404         LONG umode;
5405
5406         /* Sanity checks... */
5407         if (mode < REC_EXCLUSIVE || mode > REC_SHARED_IMMED)
5408         {
5409                 error = ERROR_ACTION_NOT_KNOWN;
5410                 goto out;
5411         }
5412
5413         /* Invalid offset, size or integer overflow? */
5414         if (offset < 0 || length <= 0 || offset + length < offset)
5415         {
5416                 error = ERROR_LOCK_COLLISION;
5417                 goto out;
5418         }
5419
5420         if ((mode == REC_SHARED) || (mode == REC_SHARED_IMMED))
5421                 umode = 1;
5422         else
5423                 umode = 0;
5424
5425         if ((mode == REC_SHARED_IMMED) || (mode == REC_EXCLUSIVE_IMMED))
5426                 timeout = 0;
5427
5428         if (timeout > 0)
5429         {
5430                 if (timeout > 214748364)
5431                         timeout = ~0;   /* wait forever */
5432                 else
5433                         timeout *= 20;  /* milliseconds instead of Ticks */
5434         }
5435
5436         error = smba_lockrec (fn->fn_File, offset, length, umode, 0, (long)timeout);
5437         if(error < 0)
5438         {
5439                 error = MapErrnoToIoErr(error);
5440                 goto out;
5441         }
5442
5443         result = DOSTRUE;
5444
5445  out:
5446
5447         (*error_ptr) = error;
5448
5449         RETURN(result);
5450         return(result);
5451 }
5452
5453 /****************************************************************************/
5454
5455 STATIC LONG
5456 Action_FreeRecord (
5457         struct FileNode *       fn,
5458         LONG                            offset,
5459         LONG                            length,
5460         SIPTR *                         error_ptr)
5461 {
5462         LONG result = DOSFALSE;
5463         LONG error;
5464
5465         /* Sanity checks... */
5466         if(offset < 0 || length <= 0 || offset + length < offset)
5467         {
5468                 error = ERROR_RECORD_NOT_LOCKED;
5469                 goto out;
5470         }
5471
5472         error = smba_lockrec (fn->fn_File, offset, length, 2, -1, 0);
5473         if (error < 0)
5474         {
5475                 error = MapErrnoToIoErr(error);
5476                 goto out;
5477         }
5478
5479         result = DOSTRUE;
5480
5481  out:
5482
5483         (*error_ptr) = error;
5484
5485         RETURN(result);
5486         return(result);
5487 }
5488
5489 /****************************************************************************/
5490
5491 STATIC VOID
5492 StartReconnectTimer(VOID)
5493 {
5494         /* Set up delay for next try */
5495         TimerRequest.tr_node.io_Command = TR_ADDREQUEST;
5496         TimerRequest.tr_node.io_Message.mn_ReplyPort = FileSystemPort;
5497         TimerRequest.tr_time.tv_secs = 2;
5498         TimerRequest.tr_time.tv_micro = 0;
5499         SendIO((struct IORequest *)&TimerRequest);
5500         TimerActive = TRUE;
5501 }
5502
5503 /****************************************************************************/
5504
5505 STATIC VOID
5506 HandleFileSystem(VOID)
5507 {
5508         BOOL sign_off = FALSE;
5509         ULONG signals;
5510         BOOL done;
5511
5512         ENTER();
5513
5514         DisplayErrorList();
5515         Quiet = TRUE;
5516         done = FALSE;
5517
5518         do
5519         {
5520                 signals = Wait(SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_F | (1UL << FileSystemPort->mp_SigBit));
5521
5522                 if(signals & (1UL << FileSystemPort->mp_SigBit))
5523                 {
5524                         struct DosPacket * dp;
5525                         struct Message * mn;
5526                         SIPTR res1,res2;
5527
5528                         while((mn = GetMsg(FileSystemPort)) != NULL)
5529                         {
5530                                 dp = (struct DosPacket *)mn->mn_Node.ln_Name;
5531
5532                                 D(("got packet (%ld); sender '%s'\n",dp->dp_Action,((struct Node *)dp->dp_Port->mp_SigTask)->ln_Name));
5533
5534                                 res2 = 0;
5535
5536
5537                                 if (mn->mn_Node.ln_Type == NT_REPLYMSG)
5538                                 {
5539                                         TimerActive = FALSE;
5540                                         AddVolume(
5541                                                 args.Service,
5542                                                 args.Workgroup,
5543                                                 args.UserName,
5544                                                 args.Password,
5545                                                 args.ClientName,
5546                                                 args.ServerName,
5547                                                 (args.CacheSize != NULL) ? *args.CacheSize : 0,
5548                                                 args.DeviceName,
5549                                                 args.VolumeName);
5550                                         continue;
5551                                 }
5552                                 if(!VolumeNodeAdded && dp->dp_Action != ACTION_STARTUP)
5553                                 {
5554                                         res1 = DOSFALSE;
5555                                         res2 = ERROR_NO_DISK;
5556                                         ReplyPkt(dp,res1,res2);
5557                                         continue;
5558                                 }
5559                                 switch(dp->dp_Action)
5560                                 {
5561                                         case ACTION_STARTUP:
5562                                                 /* FSSM,DeviceNode -> Bool */
5563
5564                                                 res1 = (IPTR)Action_Startup(
5565                                                         (struct FileSysStartupMsg *)BADDR(dp->dp_Arg2),
5566                                                         (struct DosList *)BADDR(dp->dp_Arg3),&res2);
5567                                                 if(!res1)
5568                                                         Quit = TRUE;
5569                                                 break;
5570
5571                                         case ACTION_DIE:
5572
5573                                                 SHOWMSG("ACTION_DIE");
5574                                                 if(IsListEmpty((struct List *)&FileList) && IsListEmpty((struct List *)&LockList))
5575                                                 {
5576                                                         SHOWMSG("no locks or files pending; quitting");
5577
5578                                                         res1 = DOSTRUE;
5579                                                 }
5580                                                 else
5581                                                 {
5582                                                         SHOWMSG("locks or files still pending; cannot quit yet");
5583
5584                                                         res1 = DOSFALSE;
5585                                                         res2 = ERROR_OBJECT_IN_USE;
5586                                                 }
5587
5588                                                 Quit = TRUE;
5589                                                 break;
5590
5591                                         case ACTION_CURRENT_VOLUME:
5592                                                 /* (Ignore) -> VolumeNode */
5593
5594                                                 res1 = (IPTR)MKBADDR(VolumeNode);
5595                                                 break;
5596
5597                                         case ACTION_LOCATE_OBJECT:
5598                                                 /* Lock,Name,Mode -> Lock */
5599
5600                                                 res1 = (IPTR)Action_LocateObject((struct FileLock *)BADDR(dp->dp_Arg1),(APTR)BADDR(dp->dp_Arg2),dp->dp_Arg3,&res2);
5601                                                 break;
5602
5603                                         case ACTION_RENAME_DISK:
5604                                                 /* Name -> Bool */
5605
5606                                                 res1 = Action_RenameDisk((UBYTE *)BADDR(dp->dp_Arg1),&res2);
5607                                                 break;
5608
5609                                         case ACTION_FREE_LOCK:
5610                                                 /* Lock -> Bool */
5611
5612                                                 res1 = Action_FreeLock((struct FileLock *)BADDR(dp->dp_Arg1),&res2);
5613                                                 break;
5614
5615                                         case ACTION_DELETE_OBJECT:
5616                                                 /* Lock,Name -> Bool */
5617
5618                                                 res1 = Action_DeleteObject((struct FileLock *)BADDR(dp->dp_Arg1),(APTR)BADDR(dp->dp_Arg2),&res2);
5619                                                 break;
5620
5621                                         case ACTION_RENAME_OBJECT:
5622                                                 /* Source lock,source name,destination lock,destination name -> Bool */
5623
5624                                                 res1 = Action_RenameObject((struct FileLock *)BADDR(dp->dp_Arg1),BADDR(dp->dp_Arg2),
5625                                                         (struct FileLock *)BADDR(dp->dp_Arg3),BADDR(dp->dp_Arg4),&res2);
5626
5627                                                 break;
5628
5629                                         case ACTION_MORE_CACHE:
5630                                                 /* Buffer delta -> Total number of buffers */
5631
5632                                                 /* NOTE: documentation for this packet type is inconsistent;
5633                                                  *       in the 'good old' 1.x days 'res1' was documented as
5634                                                  *       the total number of buffers to be returned. In the
5635                                                  *       2.x documentation it is said that 'res1' should
5636                                                  *       return the success code, with 'res2' to hold the
5637                                                  *       total number of buffers. However, the 'AddBuffers'
5638                                                  *       shell command doesn't work that way, and the
5639                                                  *       dos.library implementation of 'AddBuffers()' doesn't
5640                                                  *       work that way either. The 1.3 'AddBuffers' command
5641                                                  *       appears to treat a zero result as failure and a
5642                                                  *       non-zero result as success, which suggests that this
5643                                                  *       is how the packet is supposed to work, contrary to
5644                                                  *       what the official documentation says.
5645                                                  */
5646                                                 res1 = Action_MoreCache(dp->dp_Arg1,&res2);
5647                                                 break;
5648
5649                                         case ACTION_COPY_DIR:
5650                                                 /* Lock -> Lock */
5651
5652                                                 res1 = (IPTR)Action_CopyDir((struct FileLock *)BADDR(dp->dp_Arg1),&res2);
5653                                                 break;
5654
5655                                         case ACTION_SET_PROTECT:
5656                                                 /* (Ignore),Lock,Name,Mask -> Bool */
5657
5658                                                 res1 = Action_SetProtect((struct FileLock *)BADDR(dp->dp_Arg2),BADDR(dp->dp_Arg3),dp->dp_Arg4,&res2);
5659                                                 break;
5660
5661                                         case ACTION_CREATE_DIR:
5662                                                 /* Lock,Name -> Lock */
5663
5664                                                 res1 = (IPTR)Action_CreateDir((struct FileLock *)BADDR(dp->dp_Arg1),(APTR)BADDR(dp->dp_Arg2),&res2);
5665                                                 break;
5666
5667                                         case ACTION_EXAMINE_OBJECT:
5668                                                 /* FileLock,FileInfoBlock -> Bool */
5669
5670                                                 res1 = Action_ExamineObject((struct FileLock *)BADDR(dp->dp_Arg1),(struct FileInfoBlock *)BADDR(dp->dp_Arg2),&res2);
5671                                                 break;
5672
5673                                         case ACTION_EXAMINE_NEXT:
5674                                                 /* FileLock,FileInfoBlock -> Bool */
5675
5676                                                 res1 = Action_ExamineNext((struct FileLock *)BADDR(dp->dp_Arg1),(struct FileInfoBlock *)BADDR(dp->dp_Arg2),&res2);
5677                                                 break;
5678
5679                                         case ACTION_DISK_INFO:
5680                                                 /* InfoData -> Bool */
5681
5682                                                 Action_DiskInfo((struct InfoData *)BADDR(dp->dp_Arg1),&res2);
5683                                                 res1 = DOSTRUE;
5684                                                 res2 = 0;
5685                                                 break;
5686
5687                                         case ACTION_INFO:
5688                                                 /* FileLock,InfoData -> Bool */
5689
5690                                                 res1 = Action_Info((struct FileLock *)BADDR(dp->dp_Arg1),(struct InfoData *)BADDR(dp->dp_Arg2),&res2);
5691                                                 break;
5692
5693                                         case ACTION_SET_COMMENT:
5694                                                 /* (Ignore),FileLock,Name,Comment -> Bool */
5695
5696                                                 res1 = Action_SetComment((struct FileLock *)BADDR(dp->dp_Arg2),BADDR(dp->dp_Arg3),BADDR(dp->dp_Arg4),&res2);
5697                                                 break;
5698
5699                                         case ACTION_PARENT:
5700                                                 /* Lock -> Lock */
5701
5702                                                 res1 = (IPTR)Action_Parent((struct FileLock *)BADDR(dp->dp_Arg1),&res2);
5703                                                 break;
5704
5705                                         case ACTION_INHIBIT:
5706
5707                                                 SHOWMSG("ACTION_INHIBIT");
5708                                                 res1 = DOSTRUE;
5709                                                 break;
5710
5711                                         case ACTION_SET_DATE:
5712                                                 /* (Ignore),FileLock,Name,DateStamp(APTR) -> Bool */
5713
5714                                                 res1 = Action_SetDate((struct FileLock *)BADDR(dp->dp_Arg2),(APTR)BADDR(dp->dp_Arg3),(struct DateStamp *)dp->dp_Arg4,&res2);
5715                                                 break;
5716
5717                                         case ACTION_SAME_LOCK:
5718                                                 /* Lock,Lock -> Bool */
5719
5720                                                 res1 = Action_SameLock((struct FileLock *)BADDR(dp->dp_Arg1),(struct FileLock *)BADDR(dp->dp_Arg2),&res2);
5721                                                 break;
5722
5723                                         case ACTION_READ:
5724                                                 /* FileHandle->fh_Arg1,Buffer(APTR),Length -> Length */
5725
5726                                                 res1 = Action_Read((struct FileNode *)dp->dp_Arg1,(APTR)dp->dp_Arg2,dp->dp_Arg3,&res2);
5727                                                 break;
5728
5729                                         case ACTION_WRITE:
5730                                                 /* FileHandle->fh_Arg1,Buffer(APTR),Length -> Length */
5731
5732                                                 res1 = Action_Write((struct FileNode *)dp->dp_Arg1,(APTR)dp->dp_Arg2,dp->dp_Arg3,&res2);
5733                                                 break;
5734
5735                                         case ACTION_FINDUPDATE:
5736                                         case ACTION_FINDINPUT:
5737                                         case ACTION_FINDOUTPUT:
5738                                                 /* FileHandle,FileLock,Name -> Bool */
5739
5740                                                 res1 = Action_Find(dp->dp_Action,(struct FileHandle *)BADDR(dp->dp_Arg1),(struct FileLock *)BADDR(dp->dp_Arg2),(APTR)BADDR(dp->dp_Arg3),&res2);
5741                                                 break;
5742
5743                                         case ACTION_END:
5744                                                 /* FileHandle->fh_Arg1 -> Bool */
5745
5746                                                 res1 = Action_End((struct FileNode *)dp->dp_Arg1,&res2);
5747                                                 break;
5748
5749                                         case ACTION_SEEK:
5750                                                 /* FileHandle->fh_Arg1,Position,Mode -> Position */
5751
5752                                                 res1 = Action_Seek((struct FileNode *)dp->dp_Arg1,dp->dp_Arg2,dp->dp_Arg3,&res2);
5753                                                 break;
5754
5755                                         case ACTION_SET_FILE_SIZE:
5756                                                 /* FileHandle->fh_Arg1,Offset,Mode -> New file size */
5757
5758                                                 res1 = Action_SetFileSize((struct FileNode *)dp->dp_Arg1,dp->dp_Arg2,dp->dp_Arg3,&res2);
5759                                                 break;
5760
5761                                         case ACTION_WRITE_PROTECT:
5762                                                 /* Flag,Key -> Bool */
5763
5764                                                 res1 = Action_WriteProtect(dp->dp_Arg1,dp->dp_Arg2,&res2);
5765                                                 break;
5766
5767                                         case ACTION_FH_FROM_LOCK:
5768                                                 /* FileHandle(BPTR),FileLock -> Bool */
5769
5770                                                 res1 = Action_FHFromLock((struct FileHandle *)BADDR(dp->dp_Arg1),(struct FileLock *)BADDR(dp->dp_Arg2),&res2);
5771                                                 break;
5772
5773                                         case ACTION_IS_FILESYSTEM:
5774
5775                                                 SHOWMSG("ACTION_IS_FILESYSTEM");
5776                                                 res1 = DOSTRUE;
5777                                                 break;
5778
5779                                         case ACTION_CHANGE_MODE:
5780                                                 /* Type,Object,Mode -> Bool */
5781
5782                                                 res1 = Action_ChangeMode(dp->dp_Arg1,(APTR)BADDR(dp->dp_Arg2),dp->dp_Arg3,&res2);
5783                                                 break;
5784
5785                                         case ACTION_COPY_DIR_FH:
5786                                                 /* FileHandle->fh_Arg1 -> Bool */
5787
5788                                                 res1 = (IPTR)Action_CopyDirFH((struct FileNode *)dp->dp_Arg1,&res2);
5789                                                 break;
5790
5791                                         case ACTION_PARENT_FH:
5792                                                 /* FileHandle->fh_Arg1 -> Bool */
5793
5794                                                 res1 = (IPTR)Action_ParentFH((struct FileNode *)dp->dp_Arg1,&res2);
5795                                                 break;
5796
5797                                         case ACTION_EXAMINE_ALL:
5798                                                 /* FileLock,ExAllData(APTR),Size,Type,ExAllControl(APTR) -> Bool */
5799
5800                                                 res1 = Action_ExamineAll((struct FileLock *)BADDR(dp->dp_Arg1),(struct ExAllData *)dp->dp_Arg2,
5801                                                         dp->dp_Arg3,dp->dp_Arg4,(struct ExAllControl *)dp->dp_Arg5,&res2);
5802
5803                                                 break;
5804
5805                                         case ACTION_EXAMINE_FH:
5806                                                 /* FileHandle->fh_Arg1,FileInfoBlock -> Bool */
5807
5808                                                 res1 = Action_ExamineFH((struct FileNode *)dp->dp_Arg1,(struct FileInfoBlock *)BADDR(dp->dp_Arg2),&res2);
5809                                                 break;
5810
5811                                         case ACTION_EXAMINE_ALL_END:
5812                                                 /* FileLock,ExAllData(APTR),Size,Type,ExAllControl(APTR) -> Bool */
5813
5814                                                 res1 = DOSTRUE;
5815                                                 break;
5816
5817                                         case ACTION_LOCK_RECORD:
5818                                                 /* FileHandle->fh_Arg1,position,length,mode,time-out -> Bool */
5819                                                 res1 =  Action_LockRecord((struct FileNode *)dp->dp_Arg1,dp->dp_Arg2,dp->dp_Arg3,dp->dp_Arg4,(ULONG)dp->dp_Arg5,&res2);
5820                                                 break;
5821
5822                                         case ACTION_FREE_RECORD:
5823                                                 /* FileHandle->fh_Arg1,position,length -> Bool */
5824                                                 res1 =  Action_FreeRecord((struct FileNode *)dp->dp_Arg1,dp->dp_Arg2,dp->dp_Arg3,&res2);
5825                                                 break;
5826
5827                                         default:
5828
5829                                                 D(("Anything goes: dp->dp_Action=%ld (0x%lx)",dp->dp_Action,dp->dp_Action));
5830
5831                                                 res1 = DOSFALSE;
5832                                                 res2 = ERROR_ACTION_NOT_KNOWN;
5833
5834                                                 break;
5835                                 }
5836
5837                                 SHOWVALUE(res1);
5838                                 SHOWVALUE(res2);
5839
5840                                 ReplyPkt(dp,res1,res2);
5841
5842                                 D(("\n"));
5843                         }
5844                 }
5845
5846                 #if DEBUG
5847                 {
5848                         if(signals & SIGBREAKF_CTRL_F)
5849                         {
5850                                 struct FileNode * fn;
5851                                 struct LockNode * ln;
5852
5853                                 D(("list of open files:"));
5854
5855                                 for(fn = (struct FileNode *)FileList.mlh_Head ;
5856                                     fn->fn_MinNode.mln_Succ != NULL ;
5857                                     fn = (struct FileNode *)fn->fn_MinNode.mln_Succ)
5858                                 {
5859                                         D(("  name='%s'",fn->fn_FullName));
5860                                         D(("  mode=%ld, offset=%ld",fn->fn_Mode,fn->fn_Offset));
5861                                         D((""));
5862                                 }
5863
5864                                 D(("list of allocated locks:"));
5865
5866                                 for(ln = (struct LockNode *)LockList.mlh_Head ;
5867                                     ln->ln_MinNode.mln_Succ != NULL ;
5868                                     ln = (struct LockNode *)ln->ln_MinNode.mln_Succ)
5869                                 {
5870                                         D(("  name='%s'",ln->ln_FullName));
5871                                         D(("  mode=%ld",ln->ln_FileLock.fl_Access));
5872                                         D((""));
5873                                 }
5874                         }
5875                 }
5876                 #endif /* DEBUG */
5877
5878                 if(signals & SIGBREAKF_CTRL_C)
5879                         Quit = TRUE;
5880
5881                 if(Quit)
5882                 {
5883                         if(IsListEmpty((struct List *)&FileList) && IsListEmpty((struct List *)&LockList))
5884                         {
5885                                 SHOWMSG("no locks or files pending; quitting");
5886                                 done = TRUE;
5887                         }
5888                         else
5889                         {
5890                                 SHOWMSG("locks or files still pending; cannot quit yet");
5891                         }
5892                 }
5893         }
5894         while(NOT done);
5895
5896         if(sign_off)
5897                 LocalPrintf("stopped.\n");
5898
5899         LEAVE();
5900 }
5901
5902 /****************************************************************************/
5903
5904 /*
5905  * Copy src to string dst of size siz.  At most siz-1 characters
5906  * will be copied.  Always NUL terminates (unless siz == 0).
5907  * Returns strlen(src); if retval >= siz, truncation occurred.
5908  */
5909 size_t
5910 strlcpy(char *dst, const char *src, size_t siz)
5911 {
5912         char *d = dst;
5913         const char *s = src;
5914         size_t n = siz;
5915         size_t result;
5916
5917         /* Copy as many bytes as will fit */
5918         if(n != 0 && --n != 0)
5919         {
5920                 do
5921                 {
5922                         if(((*d++) = (*s++)) == '\0')
5923                                 break;
5924                 }
5925                 while(--n != 0);
5926         }
5927
5928         /* Not enough room in dst, add NUL and traverse rest of src */
5929         if(n == 0)
5930         {
5931                 if(siz != 0)
5932                         (*d) = '\0';    /* NUL-terminate dst */
5933
5934                 while((*s++) != '\0')
5935                         ;
5936         }
5937
5938         result = s - src - 1;   /* count does not include NUL */
5939
5940         return(result);
5941 }
5942
5943 /*
5944  * Appends src to string dst of size siz (unlike strncat, siz is the
5945  * full size of dst, not space left).  At most siz-1 characters
5946  * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
5947  * Returns strlen(src) + MIN(siz, strlen(initial dst)).
5948  * If retval >= siz, truncation occurred.
5949  */
5950 size_t
5951 strlcat(char *dst, const char *src, size_t siz)
5952 {
5953         char *d = dst;
5954         const char *s = src;
5955         size_t n = siz;
5956         size_t dlen;
5957         size_t result;
5958
5959         /* Find the end of dst and adjust bytes left but don't go past end */
5960         while(n-- != 0 && (*d) != '\0')
5961                 d++;
5962
5963         dlen = d - dst;
5964         n = siz - dlen;
5965
5966         if(n == 0)
5967         {
5968                 result = dlen + strlen(s);
5969         }
5970         else
5971         {
5972                 while((*s) != '\0')
5973                 {
5974                         if(n != 1)
5975                         {
5976                                 (*d++) = (*s);
5977                                 n--;
5978                         }
5979
5980                         s++;
5981                 }
5982
5983                 (*d) = '\0';
5984
5985                 result = dlen + (s - src);       /* count does not include NUL */
5986         }
5987
5988         return(result);
5989 }