开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
Unix.cpp
资源名称：warftpd.zip　[点击查看]
上传用户：surprise9
上传日期：2007-01-04
资源大小：426k
文件大小：18k
源码类别：

Ftp客户端

开发平台：

Visual C++

Unix.cpp：源码内容
  1. // This is part of the WAR SOFTWARE SERIES initiated by Jarle Aase
  2. // Copyright 1996 by Jarle Aase. All rights reserved.
  3. // See the "War Software Series Licende Agreement" for details concerning 
  4. // use and distribution.
  5. // ---
  6. // This source code, executables and programs containing source code or
  7. // binaries or proprietetary technology from the War Software Series are
  8. // NOT alloed used, viewed or tested by any governmental agencies in
  9. // any countries. This includes the government, departments, police, 
  10. // military etc.
  11. // ---
  12. // This file is intended for use with Tab space = 2
  13. // Created and maintained in MSVC Developer Studio
  14. // ---
  15. // NAME : Unix.cpp
  16. // PURPOSE : UNIX commands
  17. // PROGRAM : 
  18. // DATE : Sept. 27 1996
  19. // AUTHOR : Jarle Aase
  20. // ---
  21. // REVISION HISTORY
  22. // 
  23. // This module contains code from free-bsd
  24. /*
  25.  * Copyright (c) 1987 Regents of the University of California.
  26.  * All rights reserved.
  27.  *
  28.  * Redistribution and use in source and binary forms, with or without
  29.  * modification, are permitted provided that the following conditions
  30.  * are met:
  31.  * 1. Redistributions of source code must retain the above copyright
  32.  *    notice, this list of conditions and the following disclaimer.
  33.  * 2. Redistributions in binary form must reproduce the above copyright
  34.  *    notice, this list of conditions and the following disclaimer in the
  35.  *    documentation and/or other materials provided with the distribution.
  36.  * 3. All advertising materials mentioning features or use of this software
  37.  *    must display the following acknowledgement:
  38.  * This product includes software developed by the University of
  39.  * California, Berkeley and its contributors.
  40.  * 4. Neither the name of the University nor the names of its contributors
  41.  *    may be used to endorse or promote products derived from this software
  42.  *    without specific prior written permission.
  43.  *
  44.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  45.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  46.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  47.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  48.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  49.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  50.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  51.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  52.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  53.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  54.  * SUCH DAMAGE.
  55.  */
  57. #include "stdafx.h"
  58. #include "WarSoftware.h"
  59. #include "Unix.h"
  62. #ifdef _DEBUG
  63. #define new DEBUG_NEW
  64. #undef THIS_FILE
  65. static char THIS_FILE[] = __FILE__;
  66. #endif
  68. #define index(a,b) strchr(a,b)
  69. #define rindex(a,b) strrchr(a,b)
  71. #define BADCH (int)'?'
  72. #define EMSG ""
  74. CUnix::CUnix()
  75. {
  76. m_TmpName = NULL;
  77. m_stdio = NULL;
  78. place = EMSG;
  79. opterr = 0; /* if error message should be printed */
  80. optind = 0; /* index into parent argv vector */
  81. optopt = 0; /* character checked for validity */
  82. optarg = NULL;
  83. }
  85. CUnix::~CUnix()
  86. {
  87. if (m_TmpName)
  88. delete m_TmpName;
  89. if (m_stdio && (m_stdio != BUFFER_STDIO))
  90. fclose(m_stdio);
  91. }
  93. BOOL CUnix::Create(CCmdArgs *CmdArgs, CLog *Log, FILE *OutFile, CUserFsys *Fsys)
  94. {
  95. m_Fsys = Fsys;
  96. m_CmdArgs = CmdArgs;
  97. m_Log = Log;
  98. optind = 1;
  99. opterr = 1;
  100. m_stdio = OutFile;
  101. m_HavePrintedSomething = FALSE;
  102. m_ShowLinkAsFile = FALSE;
  103. m_UseBufferOutput = FALSE;
  105. return TRUE;
  106. }
  108. int CUnix::Exec()
  109. {
  110. if (!m_stdio)
  111. {
  112. // Open a temporary file
  113. LPCSTR TmpDir = getenv("TEMP");
  114. ASSERT(TmpDir ? AfxIsValidString(TmpDir) : TRUE);
  115. if ((m_TmpName = _tempnam(TmpDir, "~CUnix")) == NULL)
  116. {
  117. LogMsg(LOGF_WARNINGS,"Exec: Failed to get temporary file name.");
  118. return FALSE;
  119. }
  120. ASSERT(AfxIsValidString(m_TmpName));
  121. if ((m_stdio = fopen(m_TmpName,"w+b")) == NULL)
  122. {
  123. LogMsg(LOGF_WARNINGS,"Exec: Failed to open temporary file '%s'.", m_TmpName);
  124. return FALSE;
  125. }
  126. }
  127. else if (m_stdio == BUFFER_STDIO)
  128. {
  129. m_stdout.Empty();
  130. m_UseBufferOutput = TRUE;
  131. }
  133. // Call the main function
  134. ASSERT(AfxIsValidAddress(m_CmdArgs,sizeof(m_CmdArgs)));
  135. ASSERT(m_CmdArgs->m_argc >= 1);
  136. return main(m_CmdArgs->m_argc, m_CmdArgs->m_argv);
  137. }
  139. int CUnix::main(int argc, char **argv)
  140. {
  141. // Must be overridden
  142. ASSERT(FALSE);
  143. return -1;
  144. }
  146. void CUnix::LogMsg(int flag, LPCSTR Format, ...)
  147. {
  148. CString cBuf;
  149. if (!ShouldLog(m_Log, flag))
  150. return;
  152. ASSERT(AfxIsValidString(Format, FALSE));
  154. cBuf.Format("CUnix: %s", Format);
  156. va_list argList;
  157. va_start(argList, Format);
  158. m_Log->LogMsgV(flag, cBuf, argList);
  159. va_end(argList);
  160. }
  162. BOOL CUnix::BldFileInfoList(CFileInfoList& FileList, LPCSTR Path, BOOL ListDir)
  163. {
  164. return m_Fsys->BldFileInfoList(FileList, Path, ListDir);
  165. }
  168. int CUnix::printf(LPCSTR format,  ... )
  169. {
  170. ASSERT(AfxIsValidString(format));
  171. int Rval;
  172. va_list marker;
  173. va_start(marker,format);
  175. if (m_UseBufferOutput)
  176. {
  177. Rval = m_stdout.FormatCatV(format, marker);
  178. }
  179. else
  180. {
  181. Rval = ::vfprintf(m_stdio, format, marker); 
  182. }
  183. va_end(marker);
  184. BOOL m_HavePrintedSomething = TRUE;
  185. return Rval;
  186. }
  189. int CUnix::putchar(int ch)
  190. {
  191. BOOL m_HavePrintedSomething = TRUE;
  192. if (ch == 'n')
  193. return puts(m_CRLF);
  195. if (m_UseBufferOutput)
  196. {
  197. m_stdout += ch;
  198. return ch;
  199. }
  200. return fputc(ch, m_stdio);
  201. }
  203. int CUnix::putc(int ch)
  204. {
  205. BOOL m_HavePrintedSomething = TRUE;
  206. if (ch == 'n')
  207. return puts(m_CRLF);
  209. return fputc(ch, m_stdio);
  210. }
  212. int CUnix::puts(LPCSTR str)
  213. {
  214. ASSERT(AfxIsValidString(str));
  215. BOOL m_HavePrintedSomething = TRUE;
  217. if (m_UseBufferOutput)
  218. {
  219. m_stdout += str;
  220. return 1;
  221. }
  222. else
  223. return fputs(str, m_stdio);
  224. }
  229. /////////////////////////////////////////////////////////////////////////////////////
  230. // Misc standard UNIX lib functions
  233. int CUnix::getuid()
  234. {
  235. if (m_Fsys->m_IsAdmin)
  236. return 0; // root
  237. return m_Fsys->m_User;
  238. }
  240. int CUnix::getopt(int nargc, char * const *nargv, const char *ostr)
  241. {
  242. register char *oli; /* option letter list index */
  243. char *p;
  245. if (!*place) { /* update scanning pointer */
  246. if (optind >= nargc || *(place = nargv[optind]) != '-') {
  247. place = EMSG;
  248. return(EOF);
  249. }
  250. if (place[1] && *++place == '-') { /* found "--" */
  251. ++optind;
  252. place = EMSG;
  253. return(EOF);
  254. }
  255. } /* option letter okay? */
  256. if ((optopt = (int)*place++) == (int)':' ||
  257.     !(oli = index(ostr, optopt))) {
  258. /*
  259.  * if the user didn't specify '-' as an option,
  260.  * assume it means EOF.
  261.  */
  262. if (optopt == (int)'-')
  263. return(EOF);
  264. if (!*place)
  265. ++optind;
  266. if (opterr) {
  267. if (!(p = rindex(*nargv, '/')))
  268. p = *nargv;
  269. else
  270. ++p;
  271. LogMsg(LOGF_WARNINGS, "getopt(): %s: illegal option -- %cn", p, optopt);
  272. }
  273. return(BADCH);
  274. }
  275. if (*++oli != ':') { /* don't need argument */
  276. optarg = NULL;
  277. if (!*place)
  278. ++optind;
  279. }
  280. else { /* need an argument */
  281. if (*place) /* no white space */
  282. optarg = place;
  283. else if (nargc <= ++optind) { /* no arg */
  284. place = EMSG;
  285. if (!(p = rindex(*nargv, '/')))
  286. p = *nargv;
  287. else
  288. ++p;
  289. if (opterr)
  290. LogMsg(LOGF_WARNINGS, "getopt() %s: option requires an argument -- %cn", p, optopt);
  291. return(BADCH);
  292. }
  293.   else /* white space */
  294. optarg = nargv[optind];
  295. place = EMSG;
  296. ++optind;
  297. }
  298. return(optopt); /* dump back option letter */
  299. }
  302. LPCSTR CUnix::userfromuid(int uid, int nouser)
  303. {
  304. uid;
  305. nouser;
  306. return "ftp";
  307. }
  309. LPCSTR CUnix::groupfromgid(int gid, int nouser)
  310. {
  311. gid;
  312. nouser;
  313. return "ftp";
  314. }
  316. void CUnix::strmode(DWORD Flags, char *bp)
  317. {
  318. ASSERT(AfxIsValidAddress(bp, 16));
  320. sprintf(bp,"%c%c%c%c%c%c%c%c%c%c",
  321. (!m_ShowLinkAsFile && (Flags & NODE_LINK)) ? 'l' : (Flags & NODE_DIR) ? 'd' : '-',
  322. Flags & NODE_OREAD ? 'r' : '-',
  323. Flags & NODE_0WRITE ? 'w' : '-',
  324. Flags & NODE_OEXEC ? 'x' : '-',
  325. Flags & NODE_GREAD ? 'r' : '-',
  326. Flags & NODE_GWRITE ? 'w' : '-',
  327. Flags & NODE_GEXEC ? 'x' : '-',
  328. Flags & NODE_AREAD ? 'r' : '-',
  329. Flags & NODE_AWRITE ? 'w' : '-',
  330. Flags & NODE_AEXEC ? 'x' : '-');
  331. }
  333. int CUnix::readlink(LPCSTR path, LPSTR buf, int bufsiz)
  334. {
  335. return -1;
  336. }
  338. /*
  339.  * Get next token from string *stringp, where tokens are possibly-empty
  340.  * strings separated by characters from delim.
  341.  *
  342.  * Writes NULs into the string at *stringp to end tokens.
  343.  * delim need not remain constant from call to call.
  344.  * On return, *stringp points past the last NUL written (if there might
  345.  * be further tokens), or is NULL (if there are definitely no more tokens).
  346.  *
  347.  * If *stringp is NULL, strsep returns NULL.
  348.  */
  349. LPSTR CUnix::strsep(LPSTR *stringp, LPCSTR delim)
  350. {
  351. register char *s;
  352. register const char *spanp;
  353. register int c, sc;
  354. char *tok;
  356. if ((s = *stringp) == NULL)
  357. return (NULL);
  358. for (tok = s;;) {
  359. c = *s++;
  360. spanp = delim;
  361. do {
  362. if ((sc = *spanp++) == c) {
  363. if (c == 0)
  364. s = NULL;
  365. else
  366. s[-1] = 0;
  367. *stringp = s;
  368. return (tok);
  369. }
  370. } while (sc != 0);
  371. }
  372. /* NOTREACHED */
  373. }
  377. #define SET_LEN 6 /* initial # of bitcmd struct to malloc */
  378. #define SET_LEN_INCR 4 /* # of bitcmd structs to add as needed */
  380. typedef struct bitcmd {
  381. char cmd;
  382. char cmd2;
  383. int bits;
  384. } BITCMD;
  386. #define CMD2_CLR 0x01
  387. #define CMD2_SET 0x02
  388. #define CMD2_GBITS 0x04
  389. #define CMD2_OBITS 0x08
  390. #define CMD2_UBITS 0x10
  392. static void compress_mode(BITCMD *set);
  393. static BITCMD *addcmd(BITCMD *set, int op, int who, int oparg, u_int mask);
  395. /*
  396.  * Given the old mode and an array of bitcmd structures, apply the operations
  397.  * described in the bitcmd structures to the old mode, and return the new mode.
  398.  * Note that there is no '=' command; a strict assignment is just a '-' (clear
  399.  * bits) followed by a '+' (set bits).
  400.  */
  401. int CUnix::getmode(void *bbox, int omode)
  402. {
  403. register BITCMD *set;
  404. register int clrval, newmode, value;
  406. set = (BITCMD *)bbox;
  407. newmode = omode;
  408. for (value = 0;; set++)
  409. switch(set->cmd) {
  410. /*
  411.  * When copying the user, group or other bits around, we "know"
  412.  * where the bits are in the mode so that we can do shifts to
  413.  * copy them around.  If we don't use shifts, it gets real
  414.  * grundgy with lots of single bit checks and bit sets.
  415.  */
  416. case 'u':
  417. value = (newmode & S_IRWXU) >> 6;
  418. goto common;
  420. case 'g':
  421. value = (newmode & S_IRWXG) >> 3;
  422. goto common;
  424. case 'o':
  425. value = newmode & S_IRWXO;
  426. common: if (set->cmd2 & CMD2_CLR) {
  427. clrval =
  428.     (set->cmd2 & CMD2_SET) ?  S_IRWXO : value;
  429. if (set->cmd2 & CMD2_UBITS)
  430. newmode &= ~((clrval<<6) & set->bits);
  431. if (set->cmd2 & CMD2_GBITS)
  432. newmode &= ~((clrval<<3) & set->bits);
  433. if (set->cmd2 & CMD2_OBITS)
  434. newmode &= ~(clrval & set->bits);
  435. }
  436. if (set->cmd2 & CMD2_SET) {
  437. if (set->cmd2 & CMD2_UBITS)
  438. newmode |= (value<<6) & set->bits;
  439. if (set->cmd2 & CMD2_GBITS)
  440. newmode |= (value<<3) & set->bits;
  441. if (set->cmd2 & CMD2_OBITS)
  442. newmode |= value & set->bits;
  443. }
  444. break;
  446. case '+':
  447. newmode |= set->bits;
  448. break;
  450. case '-':
  451. newmode &= ~set->bits;
  452. break;
  454. case 'X':
  455. //if (omode & (S_IFDIR|S_IXUSR|S_IXGRP|S_IXOTH))
  456. if (omode & (NODE_DIR|S_IXUSR|S_IXGRP|S_IXOTH))
  457. newmode |= set->bits;
  458. break;
  460. case '':
  461. default:
  462. #ifdef SETMODE_DEBUG
  463. (void)printf("getmode:%04o -> %04on", omode, newmode);
  464. #endif
  465. return (newmode);
  466. }
  467. }
  469. #define ADDCMD(a, b, c, d)
  470. if (set >= endset) {
  471. register BITCMD *newset;
  472. setlen += SET_LEN_INCR;
  473. newset = (BITCMD *)realloc(saveset, sizeof(BITCMD) * setlen);
  474. if (!saveset)
  475. return (NULL);
  476. set = newset + (set - saveset);
  477. saveset = newset;
  478. endset = newset + (setlen - 2);
  479. }
  480. set = addcmd(set, (a), (b), (c), (d))
  482. #define STANDARD_BITS (S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO)
  485. LPVOID CUnix::setmode(LPCSTR p)
  486. {
  487. register int perm, who;
  488. register char op;
  489. BITCMD *set, *saveset, *endset;
  490. int mask = 0;
  491. int equalopdone=0, permXbits, setlen;
  493. if (!*p)
  494. return (NULL);
  496. /*
  497.  * Get a copy of the mask for the permissions that are mask relative.
  498.  * Flip the bits, we want what's not set.  Since it's possible that
  499.  * the caller is opening files inside a signal handler, protect them
  500.  * as best we can.
  501.  */
  503. setlen = SET_LEN + 2;
  505. if ((set = (BITCMD *)malloc((u_int)(sizeof(BITCMD) * setlen))) == NULL)
  506. return (NULL);
  507. saveset = set;
  508. endset = set + (setlen - 2);
  510. /*
  511.  * If an absolute number, get it and return; disallow non-octal digits
  512.  * or illegal bits.
  513.  */
  514. if (isdigit(*p)) {
  515. perm = (int)strtol(p, NULL, 8);
  516. if (perm & ~(STANDARD_BITS|S_ISTXT)) {
  517. free(saveset);
  518. return (NULL);
  519. }
  520. while (*++p)
  521. if (*p < '0' || *p > '7') {
  522. free(saveset);
  523. return (NULL);
  524. }
  525. ADDCMD('=', (STANDARD_BITS|S_ISTXT), perm, mask);
  526. return (saveset);
  527. }
  529. /*
  530.  * Build list of structures to set/clear/copy bits as described by
  531.  * each clause of the symbolic mode.
  532.  */
  533. for (;;) {
  534. /* First, find out which bits might be modified. */
  535. for (who = 0;; ++p) {
  536. switch (*p) {
  537. case 'a':
  538. who |= STANDARD_BITS;
  539. break;
  540. case 'u':
  541. who |= S_ISUID|S_IRWXU;
  542. break;
  543. case 'g':
  544. who |= S_ISGID|S_IRWXG;
  545. break;
  546. case 'o':
  547. who |= S_IRWXO;
  548. break;
  549. default:
  550. goto getop;
  551. }
  552. }
  554. getop: if ((op = *p++) != '+' && op != '-' && op != '=') {
  555. free(saveset);
  556. return (NULL);
  557. }
  558. if (op == '=')
  559. equalopdone = 0;
  561. who &= ~S_ISTXT;
  562. for (perm = 0, permXbits = 0;; ++p) {
  563. switch (*p) {
  564. case 'r':
  565. perm |= S_IRUSR|S_IRGRP|S_IROTH;
  566. break;
  567. case 's':
  568. /* If only "other" bits ignore set-id. */
  569. if (who & ~S_IRWXO)
  570. perm |= S_ISUID|S_ISGID;
  571. break;
  572. case 't':
  573. /* If only "other" bits ignore sticky. */
  574. if (who & ~S_IRWXO) {
  575. who |= S_ISTXT;
  576. perm |= S_ISTXT;
  577. }
  578. break;
  579. case 'w':
  580. perm |= S_IWUSR|S_IWGRP|S_IWOTH;
  581. break;
  582. case 'X':
  583. permXbits = S_IXUSR|S_IXGRP|S_IXOTH;
  584. break;
  585. case 'x':
  586. perm |= S_IXUSR|S_IXGRP|S_IXOTH;
  587. break;
  588. case 'u':
  589. case 'g':
  590. case 'o':
  591. /*
  592.  * When ever we hit 'u', 'g', or 'o', we have
  593.  * to flush out any partial mode that we have,
  594.  * and then do the copying of the mode bits.
  595.  */
  596. if (perm) {
  597. ADDCMD(op, who, perm, mask);
  598. perm = 0;
  599. }
  600. if (op == '=')
  601. equalopdone = 1;
  602. if (op == '+' && permXbits) {
  603. ADDCMD('X', who, permXbits, mask);
  604. permXbits = 0;
  605. }
  606. ADDCMD(*p, who, op, mask);
  607. break;
  609. default:
  610. /*
  611.  * Add any permissions that we haven't already
  612.  * done.
  613.  */
  614. if (perm || (op == '=' && !equalopdone)) {
  615. if (op == '=')
  616. equalopdone = 1;
  617. ADDCMD(op, who, perm, mask);
  618. perm = 0;
  619. }
  620. if (permXbits) {
  621. ADDCMD('X', who, permXbits, mask);
  622. permXbits = 0;
  623. }
  624. goto apply;
  625. }
  626. }
  628. apply: if (!*p)
  629. break;
  630. if (*p != ',')
  631. goto getop;
  632. ++p;
  633. }
  634. set->cmd = 0;
  635. #ifdef SETMODE_DEBUG
  636. (void)printf("Before compress_mode()n");
  637. dumpmode(saveset);
  638. #endif
  639. compress_mode(saveset);
  640. #ifdef SETMODE_DEBUG
  641. (void)printf("After compress_mode()n");
  642. dumpmode(saveset);
  643. #endif
  644. return (saveset);
  645. }
  647. static BITCMD *addcmd(BITCMD *set, int op, int who, int oparg, u_int mask)
  648. {
  649. switch (op) {
  650. case '=':
  651. set->cmd = '-';
  652. set->bits = who ? who : STANDARD_BITS;
  653. set++;
  655. op = '+';
  656. /* FALLTHROUGH */
  657. case '+':
  658. case '-':
  659. case 'X':
  660. set->cmd = op;
  661. set->bits = (who ? who : mask) & oparg;
  662. break;
  664. case 'u':
  665. case 'g':
  666. case 'o':
  667. set->cmd = op;
  668. if (who) {
  669. set->cmd2 = ((who & S_IRUSR) ? CMD2_UBITS : 0) |
  670.     ((who & S_IRGRP) ? CMD2_GBITS : 0) |
  671.     ((who & S_IROTH) ? CMD2_OBITS : 0);
  672. set->bits = ~0;
  673. } else {
  674. set->cmd2 = CMD2_UBITS | CMD2_GBITS | CMD2_OBITS;
  675. set->bits = mask;
  676. }
  678. if (oparg == '+')
  679. set->cmd2 |= CMD2_SET;
  680. else if (oparg == '-')
  681. set->cmd2 |= CMD2_CLR;
  682. else if (oparg == '=')
  683. set->cmd2 |= CMD2_SET|CMD2_CLR;
  684. break;
  685. }
  686. return (set + 1);
  687. }
  689. /*
  690.  * Given an array of bitcmd structures, compress by compacting consecutive
  691.  * '+', '-' and 'X' commands into at most 3 commands, one of each.  The 'u',
  692.  * 'g' and 'o' commands continue to be separate.  They could probably be
  693.  * compacted, but it's not worth the effort.
  694.  */
  695. static void compress_mode(BITCMD *set)
  696. {
  697. register BITCMD *nset;
  698. register int setbits, clrbits, Xbits, op;
  700. for (nset = set;;) {
  701. /* Copy over any 'u', 'g' and 'o' commands. */
  702. while ((op = nset->cmd) != '+' && op != '-' && op != 'X') {
  703. *set++ = *nset++;
  704. if (!op)
  705. return;
  706. }
  708. for (setbits = clrbits = Xbits = 0;; nset++) {
  709. if ((op = nset->cmd) == '-') {
  710. clrbits |= nset->bits;
  711. setbits &= ~nset->bits;
  712. Xbits &= ~nset->bits;
  713. } else if (op == '+') {
  714. setbits |= nset->bits;
  715. clrbits &= ~nset->bits;
  716. Xbits &= ~nset->bits;
  717. } else if (op == 'X')
  718. Xbits |= nset->bits & ~setbits;
  719. else
  720. break;
  721. }
  722. if (clrbits) {
  723. set->cmd = '-';
  724. set->cmd2 = 0;
  725. set->bits = clrbits;
  726. set++;
  727. }
  728. if (setbits) {
  729. set->cmd = '+';
  730. set->cmd2 = 0;
  731. set->bits = setbits;
  732. set++;
  733. }
  734. if (Xbits) {
  735. set->cmd = 'X';
  736. set->cmd2 = 0;
  737. set->bits = Xbits;
  738. set++;
  739. }
  740. }
  741. }
  743. int CUnix::chmod(LPCSTR path, int mode,
  744. int SetOwner, int SetClass, LPCSTR SetComment,
  745. int DefDirMode, int DefFileMode)
  746. {
  747. ASSERT(FALSE);
  748. return -1;
  749. }