/*- * $Id: hanlock.c,v 1.4 90/01/27 20:22:17 Rhialto Exp $ * $Log: hanlock.c,v $ * Revision 1.4 90/01/27 20:22:17 Rhialto * Added extra check when freeing MSFileLocks. * * Revision 1.3 90/01/23 00:36:57 Rhialto * Add an #ifndef READONLY. * * Revision 1.2 89/12/17 23:05:33 Rhialto * Add MSSetProtect * * Revision 1.1 89/12/17 20:03:01 Rhialto * * HANLOCK.C * * The code for the messydos file system handler * * The Lock department. Takes care of operations %qW1G\cb.Yf bJPLN..vFrbNv N ֔ PΆ\ *?J|M,f@43@ y$ ڸ6.ĺڴ>>>vPp 0,z,Rf2?V S`DSvHdI|Hސ"'qš%p8 $ ތ&~cD6=sh$&%m~  0RXM**"5\4>c Ԃ`GH $!]p B  @VtA%I|F ȓ"*Fs8AabkH. %II#$Ih%,gd Ҟ'L9q@70cA 0 IHNK 1ĵQ"aI>hlI$ddx9:(RpBA@H@% X< pQI0u(&9vY Ԑ/ Ac+K*, 4 *Ҡ_P2(%fP%F ("'dPEK9S$@N#j(= 0<3LC<|X C 3( _ @@  Zi\+1!@2B&ُ# ` %OgRA'[/ 40G< s  @RVTD% @aQC4& N``7@-Nef /jc Ԃ`GH $!]p B  @VtA%I|F ȓ"*Fs8AabkH. %II#$Ih%,gd Ҟ'L9q@70cA 0 IHNK 1ĵ%0Q3ꍽ Ưw{.#CHcbqCۘ*K sLch|Ȁ1'd`.ʥzבDzN~=$g,@v}wIe^rx ~ X-}0@ PRmMHAS( Y5$!I F:ilntl$z@Xfp<>8X#M《428X#6,`$@As#A%K"}Nɗّ3hH’ `%v hn?*]amMl$hq5\ fDy41t:8ϑ33P˲0ǁ?Gƞ!eg J>detgK/)f>$7CK{Gz$غ!G*BCK "?F 8 `&&%< Vz6z:OU$E$DjtT>@D`J? (l$팴u62pƐaЕ`2;vv#>D4qt񀧔a \ yX; ( XښR#2X D#NNNN| ! F[N ]ؘch2T& *t?@bp)v@3#u(2d((\~0@l;;r _ZcI8'66~N6 4k@c""&QF`wX Zhfv0u;Fe7\AƂ  q921"R1I2S JN)1$m\e(2I+*PyHءA* `@m!i4e8`C` $P@׀F $-`4 0DihH H(`FT(I.klq #rh6ȜP`s.'(0; &*AEnbg8QVC`."D,&?@g0bG (!26FBj"BÄƗ fBY JX H%/ټ yt"8{q81ry@6[q80RoPڀ"@s@ψG5o?/7(X:;00SO% q9QA% &JAx tI[8b r |=FQhV\;KN|pDhe~sOE :0:Y}?9W{g_{S8>beAA[:Ez ɓ[nu !pI'UHVXM4yP`N& n8ssfST5?N! 9%9%Ix폘f7f`3L2'^j|ȆV#aIb>G,=o^$>5=AƝ'[c$ Ԃ@8. u@|4 $H,P)Q HC"p,b&+]k &2@% 6I(FmDO֣Ё% "y2/ IC90Nn0@>[ me, de->de_Msd.msd_Ext, de->de_Msd.msd_Attributes, de->de_Msd.msd_Time, de->de_Msd.msd_Date, de->de_Msd.msd_Cluster, de->de_Msd.msd_Filesize )); } #endif /* * MakeLock makes a struct MSFileLock from a directory entry and the * parent directory MSFileLock pointer. It looks if it already has a Lock * on it. In that case, it simply increments its reference count, when * possible. */ struct MSFileLock * MakeLock(parentdir, dir, mode) struct MSFileLock *parentdir; struct DirEntry *dir; ulong mode; { register struct MSFileLock *fl; struct MSFileLock *nextfl; if (mode != EXCLUSIVE_LOCK || (dir->de_Msd.msd_Attributes & ATTR_DIR)) mode = SHARED_LOCK; #ifdef DEBUG debug(("MakeLock: ")); PrintDirEntry(dir); #endif /* * Look through our list to see if we already have it. The criteria * for this are: 1. the directory entries are the same or 2. they have * the same first cluster and are both directories (which can have * multiple directory entries). Sigh. */ for (fl = (struct MSFileLock *) LockList->ll_List.mlh_Head; nextfl = (struct MSFileLock *) fl->msfl_Node.mln_Succ; fl = nextfl) { #ifdef DEBUG debug(("> ")); PrintDirEntry(&fl->msfl_Msd); #endif if ((fl->msfl_DirSector == dir->de_Sector && fl->msfl_DirOffset == dir->de_Offset) || (fl->msfl_Msd.msd_Cluster == dir->de_Msd.msd_Cluster && (dir->de_Msd.msd_Attributes & ATTR_DIR) && (fl->msfl_Msd.msd_Attributes & ATTR_DIR)) ) { /* Found existing lock on file */ if (fl->msfl_Refcount < 0 || mode == EXCLUSIVE_LOCK) { error = ERROR_OBJECT_IN_USE; return NULL; } fl->msfl_Refcount++; return fl; } } fl = AllocMem((long) sizeof (*fl), MEMF_PUBLIC); if (fl == NULL) { error = ERROR_NO_FREE_STORE; return NULL; } fl->msfl_Parent = parentdir ? MSDupLock(parentdir) : NULL; fl->msfl_Refcount = (mode == EXCLUSIVE_LOCK) ? -1 : 1; fl->msfl_DirSector = dir->de_Sector; fl->msfl_DirOffset = dir->de_Offset; fl->msfl_Msd = dir->de_Msd; AddHead(&LockList->ll_List, fl); return fl; } /* * This routine Locks a file. It first searches it in the directory, then * lets the rest of the work be done by MakeLock(). If it encounters an * empty slot in the directory, it remembers where, in case we need it. If * you clear the MODE_CREATEFILE bit in the mode parameter, we fabricate a * new MSFileLock from the empty directory entry. It then becomes the * caller's responsibility to MSUnLock() it eventually. */ struct MSFileLock * MSLock(parentdir, name, mode) struct MSFileLock *parentdir; byte *name; ulong mode; { byte *sector; struct MSFileLock *newlock; register struct DirEntry *de; struct DirEntry sde; byte *nextpart; byte component[8 + 3]; /* Note: not null-terminated */ int createit; word freesec; word freeoffset; de = &sde; newlock = NULL; /* * See if we have an absolute path name (starting at the root). */ { register byte *colon; if (colon = index(name, ':')) { name = colon + 1; parentdir = RootLock; } } /* * Get a copy of the parent dir lock, so we can walk it over the * directory tree. */ parentdir = MSDupLock(parentdir); /* * Start with the directory entry of the parent dir. */ sde.de_Msd = parentdir->msfl_Msd; sde.de_Sector = parentdir->msfl_DirSector; sde.de_Offset = parentdir->msfl_DirOffset; #ifdef DEBUG debug(("pdir %08lx: ", parentdir)); PrintDirEntry(&parentdir->msfl_Msd); #endif newdir: freesec = SEC_EOF; /* Means none found yet */ nextpart = ToMSName(component, name); debug(("Component: '%11s'\n", component)); if (nextpart[0] != '/') { nextpart = NULL; #ifndef READONLY /* * See if we are requested to get an empty spot in the directory * if the given name does not exist already. The value of mode is * not important until we actually create the filelock. */ if (!(mode & MODE_CREATEFILE)) { mode ^= MODE_CREATEFILE; createit = 1; } else createit = 0; #endif } else nextpart++; /* * Are we at the end of the name? Then we are finished now. This works * because sde contains the directory entry of parentdir. */ if (name[0] == '\0') goto exit; /* * If there is more name, we enter the directory, and here we get the * first entry. */ sde.de_Sector = DirClusterToSector(sde.de_Msd.msd_Cluster); sde.de_Offset = 0; if ((sector = GetSec(sde.de_Sector)) == NULL) goto error; CopyMem(sector, &sde.de_Msd, (long) sizeof (struct MsDirEntry)); OtherEndianMsd(&sde.de_Msd); FreeSec(sector); while (de) { switch (CompareNames(&sde.de_Msd, component)) { case CMP_FREE_SLOT: if (freesec == SEC_EOF) { freesec = sde.de_Sector; freeoffset = sde.de_Offset; } /* Fall through */ case CMP_NOT_EQUAL: de = FindNext(&sde, createit); /* Try next directory * entry */ continue; case CMP_OK_DIR: if (name = nextpart) { /* * We want to keep locks on all directories between each * bottom directory and file lock, so we can easily find * the parent of a lock. There just seems to be a problem * here when we enter the 'subdireV*4!G*ø/۴T^ (!6EX?jX԰c.Q 1B .@HCfgy;* HثtHZL/]R Ueׅ:Vj>۠vuL"z'ygiiǿ|d]$L ͻ xфCh!IC3G1t|4$*^pD ʎ wrO̰Ϗ o&ꏯ.Hy}^+I DZ&jp'h3y.|e\pG+ma*VB(:(&)Q=?ج?_! 3ݏ) [`P-lh1-C&wT dJ$ ![m!0A3͘.%ӊu зևOOT]h  x9N?b .zZR|.ow-iwev#0"$@n.=ro5 `"h_}q0;C[IRl٥tL\b0Lݖ/ 99c1'U2|tRgO7ʹ sߏdkq vREזr ҩ^>3TOMs|agcfD +,S|6ࡌ0Ψ:ZPpF4ϜO0 )uvIX\,P2P%Bg<hfOj/b0MG*1}$< n 0V3fUzT[μz:b}fvWNro᜝7.PjO"(mMVOϯfݰqp։ÍbĴ%AZ+6uED=|@y1daG e>a ~7P1=~>>}|~0H˔\ŧ$[m%e Qmn xӢF?OaJ_d  ̈́X!Y(";..4-j[kwq4BPJk0~Pjc YSP5Pa$Z b$Ū]_wF0͡ Qb\4+H`M}͑yMgPT?jY0sgHМ@*b1N&g[s@<?RO[61!] ׷ n{_{/S ܸ EGE]eUAՎ* '@0WCă{frh 5Cf\CPBь,CP瞭*f\:=A jOY/M.rnnNL& G3qJ/ X-,&*$K倛{cteJw`wZ)U 2!hr|W ﻫ|#W6Al~B}r7ǂ cv4Z@TIB]W&ḏ.Wxyg&N:'P:^}SFB$Q{,m;Wy|z]\ާ/"0X1 f3nFFach4:Yz’~x<|!w>/X_z4za$,Fa:VꇕP?;"hnֶ?9Bг:zQؖ3XV|j.]AʨqHMK`DgVlo6﷧LepPWF^eA$\7>~T∭ Cy_MAa%`6ߘԲOOeDUij Q|կd }Z?+"$ߊLO+oyI0HacG({ 8}QX֗O]t _mas񄐶'aj"im\Ky71^(M qfĊؠdd3Lj0c+%?A䵡) o.7~I%t(̉ k7GJkBگGyPxk/^+!߫Ҝ}{9?/!{2s 5B,X46=l"dm5Q?Oqy)侤԰מ%ಃ3 'O\e)c7#'8*,y.LLSbĽ]WY_?A+[KK+iZ#V"g,}٦Sv닢##Q-up$J*[8J(4RrZp)l:;eBS`19ܻSъnҔw:"X!^nM@=Ə߅l{]'~ P<~N^5s\ zE$r`>=sxv.t &𑖔ٟV!F2xj ;0akKUlJ}| P3NiZt%﬉"ۻ*OR|qZyFe68"bHo&`H}r5$C=2[Pmiy\Z%*lF_)>㋬\N/Wg<]-kqHH Gh__+A-r%㸶xj,[R?>RV;:gL?Mf0;ϻdYv[89d>L~hӊ D+8.m+K<<s~Ƌ7?-meʵ.}NyTaPˑuqI]fu of{nP' hbGx[ ܇+Zs-GDq<)X}D]'7pt Ob0~k'HĥynFB-ci!w'`aP,0ls>hp;L2Ymbˁܗl8#S[sȹV$̠@ϝlO1t]2aj2鷴ncwlz\`cb9Lvұ\#WpqyXÏ/Bljt{ǮY|ǻ A+hG/8O0y>WqT wfPƽi+zQr] "'GU?w.&#^f'WiWڬ5+Fx8ዐX=cKmˈ@0[..L_s?/O,M>b v?i~5MI: S_B9& P?n'Rt;4fՈAAJ1Z!sxuV9ZzsuD>K$00Q6/5IF|2S,xO$%#y&ĊđpM'^%wWVn:)f `VZec?]=tH!ٿeٽvk}vՂjb^>kNfhYPGFH.vUf@./N)x)|?,kvMX Z{VS^R\KȰq>^<Ggl sector = DirClusterToSector(fl->msfl_Msd.msd_Cluster); offset = 0; } else NextDirEntry(§or, &offset); } else { skip: NextDirEntry(§or, &offset); } if (sector != SEC_EOF) { register struct MsDirEntry *msd; if (buf = GetSec(sector)) { msd = (struct MsDirEntry *) (buf + offset); if (msd->msd_Name[0] == '\0') { FreeSec(buf); goto end; } if (msd->msd_Name[0] & DIR_DELETED_MASK || msd->msd_Name[0] == '.' || /* Hide "." and ".." */ (msd->msd_Attributes & ATTR_VOLUMELABEL)) { FreeSec(buf); goto skip; } OtherEndianMsd(msd);/* Get correct endianness */ fib->fib_DiskKey = ((ulong) sector << 16) | offset; ExamineDirEntry(msd, fib); OtherEndianMsd(msd);/* Get wrong endianness */ FreeSec(buf); return DOSTRUE; } } end: error = ERROR_NO_MORE_ENTRIES; return DOSFALSE; } /* * Convert AmigaDOS protection bits to messy attribute bits. */ long MSSetProtect(parentdir, name, mask) register struct MSFileLock *parentdir; char *name; long mask; { register struct MSFileLock *lock; if (parentdir == NULL) parentdir = RootLock; lock = MSLock(parentdir, name, EXCLUSIVE_LOCK); if (lock) { /* Leave SYSTEM bit as-is */ lock->msfl_Msd.msd_Attributes &= ATTR_SYSTEM; /* write or delete protected -> READONLY */ if (mask & (FIBF_WRITE|FIBF_DELETE)) lock->msfl_Msd.msd_Attributes |= (ATTR_READONLY); /* hidden -> hidden */ if (mask & FIBF_HIDDEN) lock->msfl_Msd.msd_Attributes |= (ATTR_HIDDEN); /* archived=0 (default) -> archived=1 (default) */ if (!(mask & FIBF_ARCHIVE)) lock->msfl_Msd.msd_Attributes |= (ATTR_ARCHIVED); WriteFileLock(lock); MSUnLock(lock); return TRUE; } return FALSE; } int CheckLock(lock) register struct MSFileLock *lock; { register struct MSFileLock *parent; if (lock) { while (parent = lock->msfl_Parent) lock = parent; if (lock != RootLock) error = ERROR_DEVICE_NOT_MOUNTED; } return error; } #ifndef READONLY void WriteFileLock(fl) register struct MSFileLock *fl; { debug(("WriteFileLock %08lx\n", fl)); if (fl) { register byte *block = GetSec(fl->msfl_DirSector); if (block) { CopyMem(&fl->msfl_Msd, block + fl->msfl_DirOffset, (long) sizeof (fl->msfl_Msd)); OtherEndianMsd(block + fl->msfl_DirOffset); MarkSecDirty(block); FreeSec(block); } } } void UpdateFileLock(fl) register struct MSFileLock *fl; { struct DateStamp dateStamp; debug(("UpdateFileLock %08lx\n", fl)); DateStamp(&dateStamp); ToMSDate(&fl->msfl_Msd.msd_Date, &fl->msfl_Msd.msd_Time, &dateStamp); WriteFileLock(fl); } #endif struct LockList * NewLockList(cookie) void *cookie; { struct LockList *ll; if (ll = AllocMem((long) sizeof (*ll), MEMF_PUBLIC)) { NewList(&ll->ll_List); ll->ll_Cookie = cookie; } else error = ERROR_NO_FREE_STORE; return ll; } void FreeLockList(ll) struct LockList *ll; { debug(("FreeLockList %08lx\n", ll)); if (ll) { MayFreeVolNode(ll->ll_Cookie); /* not too happy about this */ FreeMem(ll, (long) sizeof (*ll)); if (ll == LockList) /* locks on current volume */ LockList = NULL; } }