#include <stdio.h>#include <sys/time.h>#include <sys/socket.h>#include <netinet/in.h>#include "ncftp_errno.h"
Include dependency graph for ncftp.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Classes | |
| struct | Line |
| struct | LineList |
| struct | Response |
| struct | SReadlineInfo |
| struct | FTPLibraryInfo |
| struct | FTPConnectionInfo |
| struct | FileInfo |
| struct | FileInfoList |
| struct | MLstItem |
Variables | |
| char | gLibNcFTPVersion [64] |
| int | gLibNcFTP_Uses_Me_To_Quiet_Variable_Unused_Warnings |
Macro Definition Documentation
◆ _SReadlineInfo_
◆ closesocket
◆ forever
◆ GLOBCHARSINSTR
◆ INADDR_NONE
◆ ioctlsocket
◆ IsLocalPathDelim
◆ kAcceptForReading
◆ kAcceptForWriting
◆ kAppendNo
◆ kAppendYes
◆ kChdirAndGetCWD
◆ kChdirAndMkdir
◆ kChdirOneSubdirAtATime
◆ kChdirOnly
◆ kCommandAvailabilityUnknown
◆ kCommandAvailable
◆ kCommandNotAvailable
◆ kConfirmResumeProcNotUsed
◆ kConfirmResumeProcSaidAppend
◆ kConfirmResumeProcSaidBestGuess
◆ kConfirmResumeProcSaidCancel
◆ kConfirmResumeProcSaidOverwrite
◆ kConfirmResumeProcSaidResume
◆ kConfirmResumeProcSaidSkip
◆ kDefaultAbortTimeout
◆ kDefaultConnTimeout
◆ kDefaultCtrlTimeout
◆ kDefaultDataPortMode
| #define kDefaultDataPortMode kSendPortMode |
◆ kDefaultFTPBufSize
◆ kDefaultFTPPort
◆ kDefaultMaxDials
◆ kDefaultRedialDelay
◆ kDefaultXferTimeout
◆ kDeleteNo
◆ kDeleteYes
◆ kFallBackToSendPortMode
◆ kFirewallFwuAtSiteFwpUserPass
◆ kFirewallLastType
| #define kFirewallLastType kFirewallUserAtSiteFwuPassFwp |
◆ kFirewallLoginThenUserAtSite
◆ kFirewallNotInUse
◆ kFirewallOpenSite
◆ kFirewallSiteSite
◆ kFirewallUserAtSite
◆ kFirewallUserAtSiteFwuPassFwp
◆ kFirewallUserAtUserPassAtPass
◆ kFtwDir
◆ kFtwFile
◆ kGlobChars
◆ kGlobNo
◆ kGlobYes
◆ kLibraryMagic
◆ kLibraryVersion
| #define kLibraryVersion "@(#) LibNcFTP 3.0.6 (April 14, 2001)" |
◆ kMalformedURL
◆ kMlsOptModify
◆ kMlsOptPerm
◆ kMlsOptSize
◆ kMlsOptType
◆ kMlsOptUnique
◆ kMlsOptUNIXgid
◆ kMlsOptUNIXgroup
◆ kMlsOptUNIXmode
◆ kMlsOptUNIXowner
◆ kMlsOptUNIXuid
◆ kModTimeUnknown
◆ kNetReading
| #define kNetReading kAcceptForReading |
◆ kNetWriting
| #define kNetWriting kAcceptForWriting |
◆ kNotURL
◆ kPassiveMode
◆ kPreferredMlsOpts
| #define kPreferredMlsOpts (kMlsOptType | kMlsOptSize | kMlsOptModify | kMlsOptUNIXmode | kMlsOptUNIXowner | kMlsOptUNIXgroup | kMlsOptUNIXuid | kMlsOptUNIXgid | kMlsOptPerm) |
◆ kPrEndMsg
◆ kPrInitMsg
◆ kPrUpdateMsg
◆ kRecursiveNo
◆ kRecursiveYes
◆ kRedialStatusDialing
◆ kRedialStatusSleeping
◆ kResponseNoPrint
◆ kResponseNoProc
◆ kResponseNoSave
◆ kResumeNo
◆ kResumeYes
◆ kSendPortMode
◆ kServerTypeFTP_Max
◆ kServerTypeMicrosoftFTP
◆ kServerTypeNcFTPd
◆ kServerTypeNetWareFTP
◆ kServerTypeProFTPD
◆ kServerTypeRoxen
◆ kServerTypeServ_U
◆ kServerTypeUnknown
◆ kServerTypeVFTPD
◆ kServerTypeWarFTPd
◆ kServerTypeWFTPD
◆ kServerTypeWS_FTP
◆ kServerTypeWuFTPd
◆ kSizeUnknown
| #define kSizeUnknown ((longest_int) (-1)) |
◆ kSuggestedAbortTimeout
◆ kSuggestedDefaultConnTimeout
◆ kSuggestedDefaultCtrlTimeout
| #define kSuggestedDefaultCtrlTimeout 135 /* 2*MSL, + slop */ |
◆ kSuggestedDefaultXferTimeout
◆ kTarNo
◆ kTarYes
◆ kTypeAscii
◆ kTypeBinary
◆ kTypeEbcdic
◆ LIBNCFTP_USE_VAR
| #define LIBNCFTP_USE_VAR | ( | a | ) | gLibNcFTP_Uses_Me_To_Quiet_Variable_Unused_Warnings = (a == 0) |
◆ LOCAL_PATH_DELIM
◆ LOCAL_PATH_DELIM_STR
◆ LocalPathToTVFSPath
◆ longest_int
◆ longest_uint
◆ NcSignal
◆ NO_SIGNALS
◆ NoConfirmResumeDownloadProc
| #define NoConfirmResumeDownloadProc ((ConfirmResumeDownloadProc) 0) |
◆ NoConfirmResumeUploadProc
| #define NoConfirmResumeUploadProc ((ConfirmResumeUploadProc) 0) |
◆ NoGetPassphraseProc
| #define NoGetPassphraseProc ((FTPGetPassphraseProc) 0) |
◆ StrFindLocalPathDelim
| #define StrFindLocalPathDelim | ( | a | ) | strchr(a, LOCAL_PATH_DELIM) |
◆ StrRemoveTrailingLocalPathDelim
| #define StrRemoveTrailingLocalPathDelim StrRemoveTrailingSlashes |
◆ StrRFindLocalPathDelim
| #define StrRFindLocalPathDelim | ( | a | ) | strrchr(a, LOCAL_PATH_DELIM) |
◆ TVFSPathToLocalPath
◆ UNIMPLEMENTED_CMD
◆ UNUSED
◆ USE_SIO
Typedef Documentation
◆ ConfirmResumeDownloadProc
◆ ConfirmResumeUploadProc
◆ FileInfo
◆ FileInfoList
| typedef struct FileInfoList FileInfoList |
◆ FileInfoListPtr
| typedef struct FileInfoList * FileInfoListPtr |
◆ FileInfoPtr
| typedef struct FileInfo* FileInfoPtr |
◆ FileInfoVec
| typedef struct FileInfo ** FileInfoVec |
◆ FTPCIPtr
| typedef struct FTPConnectionInfo* FTPCIPtr |
◆ FTPConnectionInfo
| typedef struct FTPConnectionInfo FTPConnectionInfo |
◆ FTPConnectMessageProc
| typedef void(* FTPConnectMessageProc) (const FTPCIPtr, ResponsePtr) |
◆ FTPFtwProc
◆ FTPGetPassphraseProc
◆ FTPLibraryInfo
| typedef struct FTPLibraryInfo FTPLibraryInfo |
◆ FTPLIPtr
| typedef struct FTPLibraryInfo * FTPLIPtr |
◆ FTPLoginMessageProc
| typedef void(* FTPLoginMessageProc) (const FTPCIPtr, ResponsePtr) |
◆ FTPLogProc
◆ FTPPrintResponseProc
| typedef void(* FTPPrintResponseProc) (const FTPCIPtr, ResponsePtr) |
◆ FTPProgressMeterProc
◆ FTPRedialStatusProc
◆ FTPSigProc
◆ Line
◆ LineList
◆ LineListPtr
| typedef struct LineList * LineListPtr |
◆ LinePtr
◆ MLstItem
◆ MLstItemPtr
| typedef struct MLstItem * MLstItemPtr |
◆ Response
◆ ResponsePtr
| typedef struct Response * ResponsePtr |
◆ SReadlineInfo
| typedef struct SReadlineInfo SReadlineInfo |
Function Documentation
◆ AddFileInfo()
| FileInfoPtr AddFileInfo | ( | FileInfoListPtr | list, |
| FileInfoPtr | src | ||
| ) |
Definition at line 530 of file linelist.c.
531{
532 FileInfoPtr lp;
533
541 list->nFileInfos = 1;
542 } else {
545 list->last = lp;
546 list->nFileInfos++;
547 }
548 }
549 return lp;
550} /* AddFileInfo */
Definition: nsiface.idl:2307
Definition: DriveVolume.h:53
Referenced by ConcatFileInfoList(), ConcatFileToFileInfoList(), FTPLocalRecursiveFileList2(), Traverse(), UnLslR(), and UnMlsD().
◆ AddLine()
| LinePtr AddLine | ( | LineListPtr | list, |
| const char * | buf1 | ||
| ) |
Definition at line 94 of file linelist.c.
95{
96 LinePtr lp;
98
103 free(lp);
104 lp = NULL;
105 } else {
111 list->nLines = 1;
112 } else {
115 list->last = lp;
116 list->nLines++;
117 }
118 }
119 }
120 return lp;
121} /* AddLine */
Definition: ncftp.h:79
Referenced by CopyLineList(), FTPDecodeURL(), FTPListToMemory2(), FTPLocalGlob(), FTPRemoteGlob(), GetResponse(), and LazyUnixLocalGlob().
◆ BufferGets()
| int BufferGets | ( | char * | buf, |
| size_t | bufsize, | ||
| int | inStream, | ||
| char * | secondaryBuf, | ||
| char ** | secBufPtr, | ||
| char ** | secBufLimit, | ||
| size_t | secBufSize | ||
| ) |
Definition at line 978 of file rcmd.c.
979{
983 char *dstlim;
986 int haveEof = 0;
987
988 err = 0;
991 src = (*secBufPtr);
994 /* Fill the buffer. */
995
996/* Don't need to poll it here. The routines that use BufferGets don't
997 * need any special processing during timeouts (i.e. progress reports),
998 * so go ahead and just let it block until there is data to read.
999 */
1002 /* EOF. */
1003 haveEof = 1;
1004 goto done;
1006 /* Error. */
1007 err = -1;
1008 goto done;
1009 }
1010 (*secBufPtr) = secondaryBuf;
1011 (*secBufLimit) = secondaryBuf + nr;
1012 src = (*secBufPtr);
1015 }
1017 ++src;
1018 } else {
1021 goto done;
1022 }
1024 }
1025 }
1026
1027done:
1028 (*secBufPtr) = src;
1034 return (-1);
1036} /* BufferGets */
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
Referenced by FTPList(), and FTPListToMemory2().
◆ ComputeLNames()
Definition at line 663 of file linelist.c.
664{
665 FileInfoPtr lp, lp2;
668
674 srcdir = cp + 1;
675 }
677 dstdir = ".";
678
680 lp2 = lp->next;
681
683 if (nochop != 0) {
686 goto memerr;
687 }
690 goto memerr;
693 goto memerr;
694 }
696 goto memerr;
697 } else {
704 } else {
705 cp++;
706 }
708 goto memerr;
709 } else {
715 } else {
716 cp++;
717 }
719 goto memerr;
720 }
721 }
723memerr:
724 return (-1);
725 }
729 }
732 }
733 return (0);
734} /* ComputeLNames */
_Check_return_ _CRTIMP _CONST_RETURN char *__cdecl strrchr(_In_z_ const char *_Str, _In_ int _Ch)
Referenced by FTPGetFiles3(), and FTPPutFiles3().
◆ ComputeRNames()
Definition at line 579 of file linelist.c.
580{
581 FileInfoPtr lp, lp2;
584
586 dstdir = ".";
587
589 lp2 = lp->next;
590
592 if (nochop != 0) {
595 goto memerr;
596
597 if (pflag != 0) {
598 /* Init lname to parent dir name of remote dir */
604 goto memerr;
606 }
607 }
608 } else {
610 goto memerr;
611 }
612 } else {
618 cp++;
619 } else {
621 }
623 goto memerr;
624
625 if (pflag != 0) {
626 /* Init lname to parent dir name of remote dir */
632 goto memerr;
634 }
635 }
636 } else {
641 cp++;
642 } else {
644 }
646 goto memerr;
647 }
648 }
651memerr:
652 return (-1);
653 }
655 }
656 return (0);
657} /* ComputeRNames */
Referenced by FTPGetFiles3(), FTPPutFiles3(), FTPRemoteRecursiveFileList(), and FTPRemoteRecursiveFileList1().
◆ ConcatFileInfoList()
| int ConcatFileInfoList | ( | FileInfoListPtr | dst, |
| FileInfoListPtr | src | ||
| ) |
Definition at line 556 of file linelist.c.
557{
558 FileInfoPtr lp, lp2;
559 FileInfo newfi;
560
562 lp2 = lp->next;
563 newfi = *lp;
570 return (-1);
571 }
572 return (0);
573} /* ConcatFileInfoList */
Referenced by FTPRemoteRecursiveFileList(), and FTPRemoteRecursiveFileList1().
◆ ConcatFileToFileInfoList()
| int ConcatFileToFileInfoList | ( | FileInfoListPtr | dst, |
| char * | rfile | ||
| ) |
Definition at line 740 of file linelist.c.
741{
742 FileInfo newfi;
743
748
750 return (-1);
751 return (0);
752} /* ConcatFileToFileInfoList */
Referenced by FTPRemoteRecursiveFileList(), FTPRemoteRecursiveFileList1(), LineListToFileInfoList(), and LineToFileInfoList().
◆ CopyLineList()
| int CopyLineList | ( | LineListPtr | dst, |
| LineListPtr | src | ||
| ) |
Definition at line 127 of file linelist.c.
128{
129 LinePtr lp, lp2;
130
133 lp2 = lp;
134 lp = lp->next;
138 return (-1);
139 }
140 }
141 }
142 return (0);
143} /* CopyLineList */
Referenced by FTPRemoteHelp().
◆ DisposeFileInfoListContents()
| void DisposeFileInfoListContents | ( | FileInfoListPtr | list | ) |
Definition at line 152 of file linelist.c.
153{
154 FileInfoPtr lp, lp2;
155
157 lp2 = lp;
158 lp = lp->next;
162 }
166 }
170 }
174 }
178 }
179 free(lp2);
180 }
181
184
185 /* Same as InitFileInfoList. */
187} /* DisposeFileInfoListContents */
Definition: ncftp.h:264
Referenced by FlushLsCacheItem(), FTPGetFiles3(), FTPPutFiles3(), FTPRemoteRecursiveFileList(), and FTPRemoteRecursiveFileList1().
◆ DisposeLineListContents()
| void DisposeLineListContents | ( | LineListPtr | list | ) |
Definition at line 33 of file linelist.c.
34{
35 LinePtr lp, lp2;
36
38 lp2 = lp;
39 lp = lp->next;
43 }
44 free(lp2);
45 }
46 /* Same as InitLineList. */
48} /* DisposeLineListContents */
Definition: ncftp.h:84
Referenced by ChdirCmd(), CopyLineList(), DoneWithResponse(), EchoCmd(), FTPChmod(), FTPDeallocateHost(), FTPDelete(), FTPFileExistsNlst(), FTPFileExistsStat(), FTPFtwL2(), FTPGetFiles3(), FTPPutFiles3(), FTPRemoteRecursiveFileList(), FTPRemoteRecursiveFileList1(), FTPRmdir(), FTPRmdirRecursiveL2(), LocalRmCmd(), LocalRmdirCmd(), Ls(), OpenCmd(), ReInitResponse(), RGlobCmd(), RmtHelpCmd(), SaveLastResponse(), SpoolGetCmd(), and SpoolPutCmd().
◆ DoneWithResponse()
| void DoneWithResponse | ( | const | FTPCIPtr, |
| ResponsePtr | rp | ||
| ) |
Definition at line 114 of file rcmd.c.
115{
116 /* Dispose space taken up by the Response, and clear it out
117 * again. For some reason, I like to return memory to zeroed
118 * when not in use.
119 */
121 TraceResponse(cip, rp);
122 if (cip->printResponseProc != 0) {
124 (*cip->printResponseProc)(cip, rp);
125 }
127 SaveLastResponse(cip, rp);
128 else
131 free(rp);
132 }
133} /* DoneWithResponse */
static void SaveLastResponse(const FTPCIPtr cip, ResponsePtr rp)
Definition: rcmd.c:89
Definition: ncftp.h:89
Referenced by FTPAbortDataTransfer(), FTPChdirAndGetCWD(), FTPCloseHost(), FTPCmd(), FTPEndDataCmd(), FTPFileExistsStat(), FTPFileModificationTime(), FTPFileSize(), FTPGetCWD(), FTPLoginHost(), FTPMListOneFile(), FTPQueryFeatures(), FTPRemoteHelp(), FTPStartDataCmd(), FTPUtime(), nFTPChdirAndGetCWD(), OpenControlConnection(), Passive(), SendPort(), and SetStartOffset().
◆ FGets()
Definition at line 111 of file util.c.
112{
114
119 if (*nlptr == '\n')
120 *nlptr = '\0';
121 } else {
123 }
125} /* FGets */
_Check_return_opt_ _CRTIMP char *__cdecl fgets(_Out_writes_z_(_MaxCount) char *_Buf, _In_ int _MaxCount, _Inout_ FILE *_File)
Referenced by GetBookmark(), GetNextBookmark(), LazyUnixLocalGlob(), OpenBookmarkFile(), PromptForBookmarkName(), PutBookmark(), and RunBookmarkEditor().
◆ FilenameExtensionIndicatesASCII()
Definition at line 963 of file util.c.
964{
965 const char *extn;
968 char extnPattern[16];
969
970 extn = pathName + strlen(pathName) - 1;
971 forever {
972 if (extn <= pathName)
973 return (0); /* End of pathname, no extension. */
976 return (0); /* End of filename, no extension. */
978 extn += 1;
979 break;
980 }
981 }
983 return (0);
984 }
985#ifdef HAVE_SNPRINTF
987#else
988 sprintf(extnPattern,
989#endif
990 "|.%s|",
991 extn
992 );
993
994 cp = extnPattern;
995 forever {
998 break;
1002 } else {
1003 cp++;
1004 }
1005 }
1006
1007 /* Extension list is specially formatted, like this:
1008 *
1009 * |ext1|ext2|ext3|...|extN|
1010 *
1011 * I.e, each filename extension is delimited with
1012 * a pipe, and we always begin and end the string
1013 * with a pipe.
1014 */
1016 return (1);
1017 }
1018 return (0);
1019} /* FilenameExtensionIndicatesASCII */
Referenced by AutomaticallyUseASCIIModeDependingOnExtension().
◆ FTPAbortDataTransfer()
Definition at line 870 of file rcmd.c.
871{
872 ResponsePtr rp;
874
878
881 /* Linger could cause close to block, so unset it. */
883 CloseDataConnection(cip);
885 return;
886 }
887
891 /* Error or no response received to ABOR in time. */
893 CloseDataConnection(cip);
895 return;
896 }
897 }
898
899 rp = InitResponse();
904 return;
905 }
906
909 /* Shouldn't happen, and doesn't matter if it does. */
911 CloseDataConnection(cip);
913 DoneWithResponse(cip, rp);
914 return;
915 }
916 DoneWithResponse(cip, rp);
917
918 /* A response to the abort request has been received.
919 * Now the only thing left to do is close the data
920 * connection, making sure to turn off linger mode
921 * since we don't care about straggling data bits.
922 */
926 }
927} /* FTPAbortDataTransfer */
int FTPCmdNoResponse(const FTPCIPtr cip, const char *const cmdspec,...)
Definition: rcmd.c:656
Referenced by FTPCloseHost(), FTPGetOneF(), and FTPPutOneF().
◆ FTPChdir()
Definition at line 11 of file cmds.c.
12{
14
19
23 } else {
24 if (cdCwd[0] == '\0') /* But allow FTPChdir(cip, ".") to go through. */
25 result = 2;
28 else
33 } else {
36 }
37 }
38 }
40} /* FTPChdir */
Referenced by FTPChdir3(), FTPFileExistsNlst(), FTPFileExistsStat(), FTPFileType(), FTPFtw(), FTPFtwL2(), FTPMkdir2(), FTPRemoteRecursiveFileList(), FTPRemoteRecursiveFileList1(), FTPRmdirRecursive(), FTPRmdirRecursiveL2(), OpenCmd(), and OpenURL().
◆ FTPChdir3()
| int FTPChdir3 | ( | FTPCIPtr | cip, |
| const char *const | cdCwd, | ||
| char *const | newCwd, | ||
| const size_t | newCwdSize, | ||
| int | flags | ||
| ) |
Definition at line 376 of file cmds.c.
377{
380 int lastSubDir;
382
387
392 }
393
408 }
409
410 /* else: (flags | kChdirOneSubdirAtATime) == true */
411
417
420
422 result = 0;
426 }
427
428 lastSubDir = 0;
429 do {
430 startcp = cp;
433 /* If this is the first slash in an absolute
434 * path, then startcp will be empty. We will
435 * use this below to treat this as the root
436 * directory.
437 */
439 } else {
440 lastSubDir = 1;
441 }
443 result = 0;
448 } else {
450 }
452 if ((mkd != 0) && (*startcp != '\0')) {
455 } else {
456 /* couldn't change nor create */
458 }
459 } else {
461 }
462 }
464
466} /* FTPChdir3 */
int FTPMkdir(const FTPCIPtr cip, const char *const newDir, const int recurse)
Definition: cmds.c:641
int FTPGetCWD(const FTPCIPtr cip, char *const newCwd, const size_t newCwdSize)
Definition: cmds.c:254
int FTPChdirAndGetCWD(const FTPCIPtr cip, const char *const cdCwd, char *const newCwd, const size_t newCwdSize)
Definition: cmds.c:313
◆ FTPChdirAndGetCWD()
| int FTPChdirAndGetCWD | ( | const FTPCIPtr | cip, |
| const char *const | cdCwd, | ||
| char *const | newCwd, | ||
| const size_t | newCwdSize | ||
| ) |
Definition at line 313 of file cmds.c.
314{
315 ResponsePtr rp;
318
323
327 } else {
328 if (cdCwd[0] == '\0') { /* But allow FTPChdir(cip, ".") to go through. */
331 }
332 rp = InitResponse();
337 } else {
340 else
344 if ((l == rp->msg.first->line) && ((r = strrchr(rp->msg.first->line, '"')) != NULL) && (l != r)) {
345 /* "xxxx" is current directory.
346 * Strip out just the xxxx to copy into the remote cwd.
347 *
348 * This is nice because we didn't have to do a PWD.
349 */
351 ++l;
354 DoneWithResponse(cip, rp);
356 } else {
357 DoneWithResponse(cip, rp);
359 }
363 DoneWithResponse(cip, rp);
364 } else {
365 DoneWithResponse(cip, rp);
366 }
367 }
368 }
370} /* FTPChdirAndGetCWD */
Referenced by FTPChdir3().
◆ FTPChmod()
| int FTPChmod | ( | const FTPCIPtr | cip, |
| const char *const | pattern, | ||
| const char *const | mode, | ||
| const int | doGlob | ||
| ) |
Definition at line 46 of file cmds.c.
47{
48 LineList fileList;
49 LinePtr filePtr;
51 int onceResult, batchResult;
52
57
60 return (batchResult);
61
63 filePtr != NULL;
64 filePtr = filePtr->next)
65 {
68 batchResult = kErrBadLineList;
70 break;
71 }
73 if (onceResult < 0) {
74 batchResult = onceResult;
75 break;
76 }
77 if (onceResult != 2) {
78 batchResult = kErrChmodFailed;
80 }
81 }
82 DisposeLineListContents(&fileList);
83 return (batchResult);
84} /* FTPChmod */
int FTPRemoteGlob(FTPCIPtr cip, LineListPtr fileList, const char *pattern, int doGlob)
Definition: glob.c:1341
Referenced by ChmodCmd().
◆ FTPCloseHost()
Definition at line 523 of file open.c.
524{
525 ResponsePtr rp;
527
532
533 /* Data connection shouldn't be open normally. */
535 FTPAbortDataTransfer(cip);
536
539 rp = InitResponse();
543 } else {
545 cip->eofOkay = 1;
547 DoneWithResponse(cip, rp);
548 }
549 }
550
551 CloseControlConnection(cip);
552
553 /* Dispose dynamic data structures, so you won't leak
554 * if you OpenHost with this again.
555 */
556 FTPDeallocateHost(cip);
558} /* FTPCloseHost */
Referenced by CloseHost(), and FTPOpenHost().
◆ FTPCmd()
Definition at line 603 of file rcmd.c.
604{
607 ResponsePtr rp;
608
613
614 rp = InitResponse();
620 }
621
623#ifndef NO_SIGNALS
626#endif /* NO_SIGNALS */
630#ifndef NO_SIGNALS
632 (void) alarm(0);
633#endif /* NO_SIGNALS */
635 }
636
637 /* Get the response to the command we sent. */
639#ifndef NO_SIGNALS
641 (void) alarm(0);
642#endif /* NO_SIGNALS */
643
646 DoneWithResponse(cip, rp);
648} /* FTPCmd */
static int SendCommand(const FTPCIPtr cip, const char *cmdspec, va_list ap)
Definition: rcmd.c:496
Referenced by DoOpen(), FTPChdir(), FTPChdir3(), FTPChmod(), FTPDelete(), FTPGetOneF(), FTPMkdir2(), FTPPutOneF(), FTPRename(), FTPRequestMlsOptions(), FTPRmdir(), FTPSetTransferType(), FTPSymlink(), FTPUmask(), QuoteCmd(), and SiteCmd().
◆ FTPCmdNoResponse()
Definition at line 656 of file rcmd.c.
657{
659
664
666#ifndef NO_SIGNALS
667 if (cip->ctrlTimeout > 0)
668 (void) alarm(cip->ctrlTimeout);
669#endif /* NO_SIGNALS */
671#ifndef NO_SIGNALS
672 if (cip->ctrlTimeout > 0)
673 (void) alarm(0);
674#endif /* NO_SIGNALS */
676
678} /* FTPCmdNoResponse */
Referenced by FTPAbortDataTransfer().
◆ FTPDecodeURL()
| int FTPDecodeURL | ( | const FTPCIPtr | cip, |
| char *const | url, | ||
| LineListPtr | cdlist, | ||
| char *const | fn, | ||
| const size_t | fnsize, | ||
| int *const | xtype, | ||
| int *const | wantnlst | ||
| ) |
Definition at line 639 of file open.c.
648{
650 char *hstart, *hend;
651 char *h2start;
652 char *at1;
653 char portstr[32];
655 int sc;
656 char *lastslash;
657 char *parsestr;
658 char *tok;
659 char subdir[128];
660 char *semi;
661
662 InitLineList(cdlist);
665 *wantnlst = 0;
667 *xtype = kTypeBinary;
668
670#ifdef HAVE_STRCASECMP
679 } else {
680 return (-1); /* not a RFC 1738 URL */
681 }
682#else /* HAVE_STRCASECMP */
691 } else {
692 return (-1); /* not a RFC 1738 URL */
693 }
694#endif /* HAVE_STRCASECMP */
695
696 /* //<user>:<password>@<host>:<port>/<url-path> */
697
698 at1 = NULL;
702 at1 = cp;
703 else
706 hend = cp;
707 break;
708 }
709 }
710
711 sc = *hend;
712 *hend = '\0';
714 /* no user or password */
715 h2start = hstart;
716 } else {
717 *at1 = '\0';
720 /* whole thing is the user name then */
723 /* Too many colons */
725 } else {
728 }
729 *at1 = '@';
730 h2start = at1 + 1;
731 }
732
735 /* whole thing is the host then */
738 /* Too many colons */
740 } else {
746 }
747
748 *hend = (char) sc;
749 if ((*hend == '\0') || ((*hend == '/') && (hend[1] == '\0'))) {
750 /* no path, okay */
751 return (0);
752 }
753
756 /* no path, okay */
757 return (0);
758 }
759 *lastslash = '\0';
760
762 *semi++ = '\0';
763#ifdef HAVE_STRCASECMP
766 *xtype = kTypeBinary;
769 *xtype = kTypeAscii;
772 *xtype = kTypeBinary;
775 *wantnlst = 1;
777 *xtype = kTypeAscii;
778 } else {
779 /* You didn't want these. */
781 }
782 }
783#else /* HAVE_STRCASECMP */
786 *xtype = kTypeBinary;
789 *xtype = kTypeAscii;
792 *xtype = kTypeBinary;
795 *wantnlst = 1;
797 *xtype = kTypeAscii;
798 } else {
799 /* You didn't want these. */
801 }
802 }
803#endif /* HAVE_STRCASECMP */
804 }
809 }
810 *lastslash = '/';
812} /* FTPDecodeURL */
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
_Check_return_ int __cdecl atoi(_In_z_ const char *_Str)
void URLCopyToken(char *dst, size_t dsize, const char *src, size_t howmuch)
Definition: open.c:598
Referenced by DecodeDirectoryURL().
◆ FTPDelete()
| int FTPDelete | ( | const FTPCIPtr | cip, |
| const char *const | pattern, | ||
| const int | recurse, | ||
| const int | doGlob | ||
| ) |
Definition at line 195 of file cmds.c.
196{
197 LineList fileList;
198 LinePtr filePtr;
200 int onceResult, batchResult;
201
206
209 return (batchResult);
210
212 filePtr != NULL;
213 filePtr = filePtr->next)
214 {
217 batchResult = kErrBadLineList;
219 break;
220 }
222 if (onceResult < 0) {
223 batchResult = onceResult;
224 break;
225 }
226 if (onceResult != 2) {
228 batchResult = kErrDELEFailed;
230 } else {
232 if (onceResult < 0) {
233 batchResult = onceResult;
234 break;
235 }
236 if (onceResult != 2) {
238 if (onceResult < 0) {
239 batchResult = kErrRMDFailed;
241 }
242 }
243 }
244 }
245 }
246 DisposeLineListContents(&fileList);
247 return (batchResult);
248} /* FTPDelete */
static int FTPRmdirRecursive(const FTPCIPtr cip, const char *const dir)
Definition: cmds.c:158
Referenced by DeleteCmd(), FTPGetOneF(), FTPPutOneF(), and FTPRmdirRecursiveL2().
◆ FTPEndDataCmd()
Definition at line 933 of file rcmd.c.
934{
936 int respCode;
937 ResponsePtr rp;
938
943
944 CloseDataConnection(cip);
946 if (didXfer) {
947 /* Get the response to the data transferred. Most likely a message
948 * saying that the transfer completed succesfully. However, if
949 * we tried to abort the transfer using ABOR, we will have a response
950 * to that command instead.
951 */
952 rp = InitResponse();
955 cip->errNo = kErrMallocFailed;
956 result = cip->errNo;
958 }
962 respCode = rp->codeType;
963 DoneWithResponse(cip, rp);
964 if (respCode != 2) {
965 cip->errNo = kErrDataTransferFailed;
966 result = cip->errNo;
967 } else {
969 }
970 }
972} /* FTPEndDataCmd */
Referenced by FTPGetOneF(), FTPList(), FTPListToMemory2(), FTPPutOneF(), and FTPStartDataCmd().
◆ FTPFileExists()
Definition at line 1423 of file cmds.c.
1424{
1426} /* FTPFileExists */
int FTPFileExists2(const FTPCIPtr cip, const char *const file, const int tryMDTM, const int trySIZE, const int tryMLST, const int trySTAT, const int tryNLST)
Definition: cmds.c:1350
◆ FTPFileExists2()
| int FTPFileExists2 | ( | const FTPCIPtr | cip, |
| const char *const | file, | ||
| const int | tryMDTM, | ||
| const int | trySIZE, | ||
| const int | tryMLST, | ||
| const int | trySTAT, | ||
| const int | tryNLST | ||
| ) |
Definition at line 1350 of file cmds.c.
1351{
1353 time_t mdtm;
1355 MLstItem mlsInfo;
1356
1357 if (tryMDTM != 0) {
1364 }
1365 /* else keep going */
1366 }
1367
1368 if (trySIZE != 0) {
1372 /* SIZE could fail if the server does
1373 * not support it for directories.
1374 *
1375 * if (result == kErrSIZEFailed)
1376 * return (kErrNoSuchFileOrDirectory);
1377 */
1378 /* else keep going */
1379 }
1380
1381
1382 if (tryMLST != 0) {
1389 }
1390 /* else keep going */
1391 }
1392
1393 if (trySTAT != 0) {
1400 }
1401 /* else keep going */
1402 }
1403
1404 if (tryNLST != 0) {
1411 }
1412 /* else keep going */
1413 }
1414
1417} /* FTPFileExists2 */
int FTPMListOneFile(const FTPCIPtr cip, const char *const file, const MLstItemPtr mlip)
Definition: cmds.c:947
int FTPFileExistsStat(const FTPCIPtr cip, const char *const file)
Definition: cmds.c:1008
int FTPFileModificationTime(const FTPCIPtr cip, const char *const file, time_t *const mdtm)
Definition: cmds.c:649
int FTPFileExistsNlst(const FTPCIPtr cip, const char *const file)
Definition: cmds.c:1209
int FTPFileSize(const FTPCIPtr cip, const char *const file, longest_int *const size, const int type)
Definition: cmds.c:887
Definition: ncftp.h:275
Referenced by FTPFileExists(), FTPFileType(), and FTPPutOneF().
◆ FTPFileExistsNlst()
Definition at line 1209 of file cmds.c.
1210{
1212 LineList fileList, rootFileList;
1213 char savedCwd[512];
1214
1219
1222
1226 }
1227
1229 /* First, make sure that when we NLST a pathname
1230 * that does not exist, that we get an error back.
1231 *
1232 * We also assume that a valid NLST response has
1233 * at least 3 lines of response text, typically
1234 * a "start" line, intermediate data, and then
1235 * a trailing line.
1236 *
1237 * We also can see a one-line case.
1238 */
1239 if (
1241 (fileList.nLines >= 1) &&
1246
1247 ) {
1250 DisposeLineListContents(&fileList);
1252 }
1253 DisposeLineListContents(&fileList);
1254
1255 /* We can't assume that we can simply say NLST rootdir/firstfile,
1256 * since the remote host may not be using / as a directory
1257 * delimiter. So we have to change to the root directory
1258 * and then do the NLST on that file.
1259 */
1260 if (
1263 ) {
1265 }
1266
1267 /* OK, we get an error when we list
1268 * a non-existant file, but now we need to
1269 * see if we get a positive reply when
1270 * we stat a file that does exist.
1271 *
1272 * To do this, we list the root directory,
1273 * which we assume has one or more items.
1274 * If it doesn't, the user can't do anything
1275 * anyway. Then we do the first item
1276 * we found to see if NLST says it exists.
1277 */
1278 if (
1282 ) {
1283 /* Hmmm... well, in any case we can't use NLST. */
1286 DisposeLineListContents(&rootFileList);
1289 }
1290
1291 if (
1293 (fileList.nLines >= 1) &&
1298
1299 ) {
1300 /* Good. We listed the item. */
1301 DisposeLineListContents(&fileList);
1302 DisposeLineListContents(&rootFileList);
1304
1305 /* Don't forget to change back to the original directory. */
1307 } else {
1310 DisposeLineListContents(&fileList);
1311 DisposeLineListContents(&rootFileList);
1314 }
1315 }
1316
1317 /* Check the requested item. */
1318 InitLineList(&fileList);
1319 if (
1321 (fileList.nLines >= 1) &&
1326
1327 ) {
1328 /* The item existed. */
1330 } else {
1333 }
1334
1335 DisposeLineListContents(&fileList);
1337} /* FTPFileExistsNlst*/
int FTPListToMemory2(const FTPCIPtr cip, const char *const pattern, const LineListPtr llines, const char *const lsflags, const int blankLines, int *const tryMLSD)
Definition: io.c:366
Referenced by FTPFileExists2().
◆ FTPFileExistsStat()
Definition at line 1008 of file cmds.c.
1009{
1011 ResponsePtr rp;
1012 LineList fileList;
1013 char savedCwd[512];
1014
1019
1022
1026 }
1027
1029 rp = InitResponse();
1035
1036 }
1037
1038 /* First, make sure that when we STAT a pathname
1039 * that does not exist, that we get an error back.
1040 *
1041 * We also assume that a valid STAT response has
1042 * at least 3 lines of response text, typically
1043 * a "start" line, intermediate data, and then
1044 * a trailing line.
1045 *
1046 * We also can see a one-line case.
1047 */
1050 /* Hmmm.... it gave back a positive
1051 * response. So STAT <file> does not
1052 * work correctly.
1053 */
1054 if (
1057 (
1060 )
1061 ) {
1062 /* OK, while we didn't want a 200
1063 * level response, some servers,
1064 * like wu-ftpd print an error
1065 * message "No such file or
1066 * directory" which we can special
1067 * case.
1068 */
1070 } else {
1073 DoneWithResponse(cip, rp);
1075 }
1076 }
1077 DoneWithResponse(cip, rp);
1078
1079 /* We can't assume that we can simply say STAT rootdir/firstfile,
1080 * since the remote host may not be using / as a directory
1081 * delimiter. So we have to change to the root directory
1082 * and then do the STAT on that file.
1083 */
1084 if (
1087 ) {
1089 }
1090
1091 /* OK, we get an error when we stat
1092 * a non-existant file, but now we need to
1093 * see if we get a positive reply when
1094 * we stat a file that does exist.
1095 *
1096 * To do this, we list the root directory,
1097 * which we assume has one or more items.
1098 * If it doesn't, the user can't do anything
1099 * anyway. Then we stat the first item
1100 * we found to see if STAT says it exists.
1101 */
1102 if (
1106 ) {
1107 /* Hmmm... well, in any case we can't use STAT. */
1110 DisposeLineListContents(&fileList);
1113 }
1114
1115 rp = InitResponse();
1120 DisposeLineListContents(&fileList);
1123
1124 }
1125
1127 DisposeLineListContents(&fileList);
1128
1130 /* Hmmm.... it gave back a negative
1131 * response. So STAT <file> does not
1132 * work correctly.
1133 */
1136 DoneWithResponse(cip, rp);
1139 } else if (
1142 (
1145 )
1146 ) {
1147 /* Same special-case of the second line of STAT response. */
1150 DoneWithResponse(cip, rp);
1153 }
1154 DoneWithResponse(cip, rp);
1156
1157 /* Don't forget to change back to the original directory. */
1159 }
1160
1161 rp = InitResponse();
1167 }
1168
1173 if (
1176 (
1179 )
1180 ) {
1183 } else {
1185 }
1189 } else {
1191 }
1192 } else {
1195 }
1196 DoneWithResponse(cip, rp);
1198} /* FTPFileExistsStat */
Referenced by FTPFileExists2().
◆ FTPFileModificationTime()
Definition at line 649 of file cmds.c.
650{
652 ResponsePtr rp;
653
658
661 *mdtm = kModTimeUnknown;
662
666 } else {
667 rp = InitResponse();
672 } else {
675 DoneWithResponse(cip, rp);
689 } else {
692 }
693 DoneWithResponse(cip, rp);
694 }
695 }
697} /* FTPFileModificationTime */
Referenced by FTPFileExists2(), FTPFileSizeAndModificationTime(), and FTPGetOneF().
◆ FTPFileSize()
| int FTPFileSize | ( | const FTPCIPtr | cip, |
| const char *const | file, | ||
| longest_int *const | size, | ||
| const int | type | ||
| ) |
Definition at line 887 of file cmds.c.
888{
890 ResponsePtr rp;
891
896
900
904
908 } else {
909 rp = InitResponse();
914 } else {
917 DoneWithResponse(cip, rp);
920#if defined(HAVE_LONG_LONG) && defined(SCANF_LONG_LONG)
922#elif defined(HAVE_LONG_LONG) && defined(HAVE_STRTOQ)
924#else
926#endif
933 } else {
936 }
937 DoneWithResponse(cip, rp);
938 }
939 }
941} /* FTPFileSize */
_Check_return_ _CRTIMP int __cdecl sscanf(_In_z_ const char *_Src, _In_z_ _Scanf_format_string_ const char *_Format,...)
Referenced by FTPFileExists2(), and FTPFileSizeAndModificationTime().
◆ FTPFileSizeAndModificationTime()
| int FTPFileSizeAndModificationTime | ( | const FTPCIPtr | cip, |
| const char *const | file, | ||
| longest_int *const | size, | ||
| const int | type, | ||
| time_t *const | mdtm | ||
| ) |
Definition at line 1433 of file cmds.c.
1434{
1435 MLstItem mlsInfo;
1437
1442
1445
1446 *mdtm = kModTimeUnknown;
1448
1452
1455 /* Do it the regular way, where
1456 * we do a SIZE and then a MDTM.
1457 */
1463 } else {
1464 *mdtm = mlsInfo.ftime;
1466 }
1467
1469} /* FTPFileSizeAndModificationTime */
Referenced by FTPGetOneF(), and FTPPutOneF().
◆ FTPFileType()
Definition at line 1475 of file cmds.c.
1476{
1478 MLstItem mlsInfo;
1479
1484
1488 }
1489
1493 }
1494
1495 *ftype = 0;
1498 *ftype = mlsInfo.ftype;
1500 }
1501
1502 /* Preserve old working directory. */
1504
1507 *ftype = 'd';
1508 /* Yes it was a directory, now go back to
1509 * where we were.
1510 */
1512
1513 /* Note: This improperly assumes that we
1514 * will be able to chdir back, which is
1515 * not guaranteed.
1516 */
1518 }
1519
1523
1525} /* FTPFileType */
#define kErrFileExistsButCannotDetermineType
Definition: ncftp_errno.h:107
Referenced by FTPIsDir(), and FTPIsRegularFile().
◆ FTPFtw()
Definition at line 1706 of file glob.c.
1707{
1710 char savedcwd[1024];
1711 char curcwd[2048];
1712
1715 /* error */
1720 }
1721
1722 /* Preserve old working directory. */
1724
1728 }
1729
1730 /* Get full working directory we just changed to. */
1736 }
1738 }
1739
1740 result2 = (*proc)(cip, curcwd, kFtwDir);
1743
1746 else
1750 }
1751
1752
1754 /* Could not cd back to the original user directory -- bad. */
1756 cip->errNo = kErrCannotGoToPrevDir;
1758 }
1759
1761 result = result2;
1762
1764} /* FTPFtw */
static int FTPFtwL2(const FTPCIPtr cip, char *dir, char *end, size_t dirsize, FTPFtwProc proc, int maxdepth)
Definition: glob.c:1624
◆ FTPGetCWD()
Definition at line 254 of file cmds.c.
255{
256 ResponsePtr rp;
259
264
268 } else {
269 rp = InitResponse();
274 } else {
278 /* "xxxx" is current directory.
279 * Strip out just the xxxx to copy into the remote cwd.
280 */
284 ++l;
287 }
288 } else {
289 /* xxxx is current directory.
290 * Mostly for VMS.
291 */
296 }
297 }
302 }
303 DoneWithResponse(cip, rp);
304 }
305 }
307} /* FTPGetCWD */
Referenced by FTPChdir3(), FTPChdirAndGetCWD(), FTPFileExistsNlst(), FTPFileExistsStat(), FTPFileType(), FTPFtw(), FTPLoginHost(), FTPMkdir2(), FTPRemoteRecursiveFileList(), FTPRemoteRecursiveFileList1(), FTPRmdirRecursive(), nFTPChdirAndGetCWD(), OpenCmd(), OpenURL(), and PwdCmd().
◆ FTPGetFiles()
| int FTPGetFiles | ( | const FTPCIPtr | cip, |
| const char *const | pattern, | ||
| const char *const | dstdir, | ||
| const int | recurse, | ||
| const int | doGlob | ||
| ) |
Definition at line 2730 of file io.c.
2731{
2732 return (FTPGetFiles3(cip, pattern, dstdir, recurse, doGlob, kTypeBinary, kResumeNo, kAppendNo, kDeleteNo, kTarYes, (ConfirmResumeDownloadProc) 0, 0));
2733} /* FTPGetFiles */
int FTPGetFiles3(const FTPCIPtr cip, const char *pattern1, const char *const dstdir1, const int recurse, int doGlob, const int xtype, const int resumeflag, int appendflag, const int deleteflag, const int tarflag, const ConfirmResumeDownloadProc resumeProc, int UNUSED(reserved))
Definition: io.c:2486
int(* ConfirmResumeDownloadProc)(const char *volatile *localpath, volatile longest_int localsize, volatile time_t localmtime, const char *volatile remotepath, volatile longest_int remotesize, volatile time_t remotetime, volatile longest_int *volatile startPoint)
Definition: ncftp.h:431
◆ FTPGetFiles2()
| int FTPGetFiles2 | ( | const FTPCIPtr | cip, |
| const char *const | pattern, | ||
| const char *const | dstdir, | ||
| const int | recurse, | ||
| const int | doGlob, | ||
| const int | xtype, | ||
| const int | resumeflag, | ||
| const int | appendflag | ||
| ) |
Definition at line 2739 of file io.c.
2740{
2741 return (FTPGetFiles3(cip, pattern, dstdir, recurse, doGlob, xtype, resumeflag, appendflag, kDeleteNo, kTarYes, (ConfirmResumeDownloadProc) 0, 0));
2742} /* FTPGetFiles2 */
◆ FTPGetFiles3()
| int FTPGetFiles3 | ( | const FTPCIPtr | cip, |
| const char * | pattern, | ||
| const char *const | dstdir, | ||
| const int | recurse, | ||
| int | doGlob, | ||
| const int | xtype, | ||
| const int | resumeflag, | ||
| int | appendflag, | ||
| const int | deleteflag, | ||
| const int | tarflag, | ||
| const ConfirmResumeDownloadProc | resumeProc, | ||
| int | reserved | ||
| ) |
◆ FTPGetFilesAscii()
| int FTPGetFilesAscii | ( | const FTPCIPtr | cip, |
| const char *const | pattern, | ||
| const char *const | dstdir, | ||
| const int | recurse, | ||
| const int | doGlob | ||
| ) |
Definition at line 2757 of file io.c.
2758{
2759 return (FTPGetFiles3(cip, pattern, dstdir, recurse, doGlob, kTypeAscii, kResumeNo, kAppendNo, kDeleteNo, kTarNo, (ConfirmResumeDownloadProc) 0, 0));
2760} /* FTPGetFilesAscii */
◆ FTPGetLocalCWD()
Definition at line 29 of file util.c.
30{
31#ifdef HAVE_GETCWD
33 static size_t cwdBufSize = 0;
34
35 if (cwdBufSize == 0) {
36 cwdBufSize = (size_t) 128;
38 }
39
43 }
44
46 break;
50 }
51 cwdBufSize *= 2;
53 }
54
56#else
57#ifdef HAVE_GETWD
59 char *dp;
60
61 /* Due to the way getwd is usually implemented, it's
62 * important to have a buffer large enough to hold the
63 * whole thing. getwd usually starts at the end of the
64 * buffer, and works backwards, returning you a pointer
65 * to the beginning of it when it finishes.
66 */
68 /* Buffer not big enough, so use a temporary one,
69 * and then copy the first 'size' bytes of the
70 * temporary buffer to your 'buf.'
71 */
76 }
77 }
78 dp = cwdBuf;
79 } else {
80 /* Buffer is big enough already. */
81 dp = buf;
82 }
83 *dp = '\0';
85 /* getwd() should write the reason why in the buffer then,
86 * according to the man pages.
87 */
90 }
92
93#elif defined(WIN32) || defined(_WINDOWS)
98#else
99 /* Not a solution, but does anybody not have either of
100 * getcwd or getwd?
101 */
102 --Error--;
103#endif
104#endif
105} /* GetCWD */
_Check_return_ _Ret_opt_z_ _CRTIMP char *__cdecl getcwd(_Out_writes_opt_(_SizeInBytes) char *_DstBuf, _In_ int _SizeInBytes)
void * Realloc(void *, size_t)
Referenced by DoOpen(), LocalChdirCmd(), LocalPwdCmd(), PostInit(), SpoolGetCmd(), SpoolPutCmd(), and SpoolX().
◆ FTPGetOneFile()
Definition at line 2712 of file io.c.
2713{
2714 return (FTPGetOneFile3(cip, file, dstfile, kTypeBinary, -1, kResumeNo, kAppendNo, kDeleteNo, (ConfirmResumeDownloadProc) 0, 0));
2715} /* FTPGetOneFile */
int FTPGetOneFile3(const FTPCIPtr cip, const char *const file, const char *const dstfile, const int xtype, const int fdtouse, const int resumeflag, const int appendflag, const int deleteflag, const ConfirmResumeDownloadProc resumeProc, int UNUSED(reserved))
Definition: io.c:2451
◆ FTPGetOneFile2()
| int FTPGetOneFile2 | ( | const FTPCIPtr | cip, |
| const char *const | file, | ||
| const char *const | dstfile, | ||
| const int | xtype, | ||
| const int | fdtouse, | ||
| const int | resumeflag, | ||
| const int | appendflag | ||
| ) |
Definition at line 2721 of file io.c.
2722{
2723 return (FTPGetOneFile3(cip, file, dstfile, xtype, fdtouse, resumeflag, appendflag, kDeleteNo, (ConfirmResumeDownloadProc) 0, 0));
2724} /* FTPGetOneFile2 */
◆ FTPGetOneFile3()
| int FTPGetOneFile3 | ( | const FTPCIPtr | cip, |
| const char *const | file, | ||
| const char *const | dstfile, | ||
| const int | xtype, | ||
| const int | fdtouse, | ||
| const int | resumeflag, | ||
| const int | appendflag, | ||
| const int | deleteflag, | ||
| const ConfirmResumeDownloadProc | resumeProc, | ||
| int | reserved | ||
| ) |
◆ FTPGetOneFileAscii()
Definition at line 2748 of file io.c.
2749{
2750 return (FTPGetOneFile3(cip, file, dstfile, kTypeAscii, -1, kResumeNo, kAppendNo, kDeleteNo, (ConfirmResumeDownloadProc) 0, 0));
2751} /* FTPGetOneFileAscii */
◆ FTPInitConnectionInfo()
Definition at line 984 of file open.c.
985{
986 size_t siz;
987
990
993
996
1011 cip->lip = lip;
1035} /* FTPInitConnectionInfo */
Definition: ncftp.h:134
Referenced by InitConnectionInfo().
◆ FTPInitializeAnonPassword()
Definition at line 81 of file open.c.
82{
84 return;
86 return;
87
88 FTPInitializeOurHostName(lip);
89
90 if (lip->defaultAnonPassword[0] == '\0') {
91#ifdef SPAM_PROBLEM_HAS_BEEN_SOLVED_FOREVER
94
95 /* Default to the "user@" notation
96 * supported by NcFTPd and wu-ftpd.
97 */
98 if (lip->htried > 0)
100#else
102#endif
103 }
104} /* FTPInitializeAnonPassword */
Referenced by FTPLoginHost(), and PostInitPrefs().
◆ FTPInitializeOurHostName()
Definition at line 63 of file open.c.
64{
66 return;
68 return;
69
70 if (lip->htried == 0) {
73 }
74 lip->htried++;
75} /* FTPInitializeOurHostName */
Referenced by FTPInitializeAnonPassword(), LoadFirewallPrefs(), OpenTrace(), and WriteDefaultFirewallPrefs().
◆ FTPInitIOTimer()
Definition at line 71 of file io.c.
72{
73 cip->bytesTransferred = (longest_int) 0;
74 cip->expectedSize = kSizeUnknown;
75 cip->mdtm = kModTimeUnknown;
76 cip->rname = NULL;
77 cip->lname = NULL;
78 cip->kBytesPerSec = -1.0;
79 cip->percentCompleted = -1.0;
80 cip->sec = -1.0;
81 cip->secLeft = -1.0;
82 cip->nextProgressUpdate = 0;
83 cip->stalled = 0;
84 cip->dataTimedOut = 0;
85 cip->useProgressMeter = 1;
87} /* FTPInitIOTimer */
Referenced by FTPGetOneF(), and FTPPutOneF().
◆ FTPInitLibrary()
Definition at line 1110 of file open.c.
1111{
1113
1116
1120 else
1122
1123 lip->init = 1;
1125
1126 /* We'll initialize the defaultAnonPassword field
1127 * later when we try the first anon ftp connection.
1128 */
1129
1130#ifdef HAVE_LIBSOCKS
1131 SOCKSinit("libncftp");
1132 lip->socksInit = 1;
1133#endif
1135} /* FTPInitLibrary */
PSERVENT WSAAPI getservbyname(IN const char FAR *name, IN const char FAR *proto)
Definition: getxbyxx.c:500
Definition: ncftp.h:113
Definition: winsock.h:158
Referenced by PreInit().
◆ FTPIsDir()
Definition at line 1531 of file cmds.c.
1532{
1534
1539
1543 }
1544
1547 result = 0;
1548 if (ftype == 'd')
1549 result = 1;
1550 }
1552} /* FTPIsDir */
int FTPFileType(const FTPCIPtr cip, const char *const file, int *const ftype)
Definition: cmds.c:1475
Referenced by FTPFtw(), FTPFtwL2(), and FTPGetFiles3().
◆ FTPIsRegularFile()
◆ FTPList()
Definition at line 174 of file io.c.
175{
178 char secondaryBuf[768];
179#ifndef NO_SIGNALS
180 char *secBufPtr, *secBufLimit;
181 int nread;
183#else /* NO_SIGNALS */
184 SReadlineInfo lsSrl;
186#endif /* NO_SIGNALS */
187
192
196 } else {
198 }
199
200
201#ifdef NO_SIGNALS
202
204 if (InitSReadlineInfo(&lsSrl, cip->dataSocket, secondaryBuf, sizeof(secondaryBuf), (int) cip->xferTimeout, 1) < 0) {
205 /* Not really fdopen, but close in what we're trying to do. */
210 }
211
212 for (;;) {
215 /* timeout */
220 /* end of listing -- done */
221 cip->numListings++;
222 break;
224 /* error */
228 break;
229 }
230
232 }
233
234 DisposeSReadlineInfo(&lsSrl);
238 }
242 }
243
244
245#else /* NO_SIGNALS */
246
248 /* This line sets the buffer pointer so that the first thing
249 * BufferGets will do is reset and fill the buffer using
250 * real I/O.
251 */
252 secBufPtr = secondaryBuf + sizeof(secondaryBuf);
253 secBufLimit = (char *) 0;
254
255 for (;;) {
258 nread = BufferGets(line, sizeof(line), cip->dataSocket, secondaryBuf, &secBufPtr, &secBufLimit, sizeof(secondaryBuf));
259 if (nread <= 0) {
260 if (nread < 0)
261 break;
262 } else {
266 }
267 }
269 (void) alarm(0);
274 }
276 cip->numListings++;
280 }
281#endif /* NO_SIGNALS */
283} /* FTPList */
int InitSReadlineInfo(SReadlineInfo *, int, char *, size_t, int, int)
Definition: SReadline.c:24
int BufferGets(char *, size_t, int, char *, char **, char **, size_t)
Definition: rcmd.c:978
int FTPStartDataCmd(const FTPCIPtr, int, int, longest_int, const char *,...)
Definition: rcmd.c:763
Definition: ncftp.h:100
Definition: ftp_var.h:139
Definition: parser.c:49
◆ FTPListToMemory()
| int FTPListToMemory | ( | const FTPCIPtr | cip, |
| const char *const | pattern, | ||
| const LineListPtr | llines, | ||
| const char *const | lsflags | ||
| ) |
◆ FTPListToMemory2()
| int FTPListToMemory2 | ( | const FTPCIPtr | cip, |
| const char *const | pattern, | ||
| const LineListPtr | llines, | ||
| const char *const | lsflags, | ||
| const int | blanklines, | ||
| int *const | tryMLSD | ||
| ) |
Definition at line 366 of file io.c.
367{
368 char secondaryBuf[768];
370 char lsflags1[128];
372 const char *scp;
373 char *dcp, *lim;
374#ifndef NO_SIGNALS
375 char *secBufPtr, *secBufLimit;
378 int sj;
379 int nread;
381#else /* NO_SIGNALS */
382 SReadlineInfo lsSrl;
384#endif /* NO_SIGNALS */
385
390
393
396 if ((lsflags[0] == '-') && (strchr(lsflags, 'd') != NULL) && (cip->hasMLST == kCommandAvailable))
398 lsflags1[0] = '\0';
399 FTPRequestMlsOptions(cip);
400 } else {
401 /* Not using MLSD. */
402 if (tryMLSD != (int *) 0)
403 *tryMLSD = 0;
404 if (lsflags[0] == '-') {
405 /* See if we should use LIST instead. */
406 scp = lsflags + 1;
407 dcp = lsflags1;
408 lim = lsflags1 + sizeof(lsflags1) - 2;
409 for (; *scp != '\0'; scp++) {
410 if (*scp == 'l') {
411 /* do not add the 'l' */
413 } else if (dcp < lim) {
414 if (dcp == lsflags1)
415 *dcp++ = '-';
416 *dcp++ = *scp;
417 }
418 }
419 *dcp = '\0';
420 } else {
422 }
423 }
424
425 InitLineList(llines);
426
428 cip,
429 kNetReading,
430 kTypeAscii,
431 (longest_int) 0,
432 "%s%s%s%s%s",
433 command,
434 (lsflags1[0] == '\0') ? "" : " ",
435 lsflags1,
437 pattern
438 );
439
440#ifdef NO_SIGNALS
441
443 if (InitSReadlineInfo(&lsSrl, cip->dataSocket, secondaryBuf, sizeof(secondaryBuf), (int) cip->xferTimeout, 1) < 0) {
444 /* Not really fdopen, but close in what we're trying to do. */
449 }
450
451 for (;;) {
454 /* timeout */
459 /* end of listing -- done */
460 cip->numListings++;
461 break;
463 /* error */
467 break;
468 }
469
472
474 continue;
475
476 /* Valid directory listing line of output */
477 if ((line[0] == '.') && ((line[1] == '\0') || ((line[1] == '.') && ((line[2] == '\0') || (iscntrl(line[2]))))))
478 continue; /* Skip . and .. */
479
481 }
482
483 DisposeSReadlineInfo(&lsSrl);
487 }
491 }
492
493
494#else /* NO_SIGNALS */
495 vcip = cip;
497
498 gGotBrokenData = 0;
499 gCanBrokenDataJmp = 0;
500
501#ifdef HAVE_SIGSETJMP
502 sj = sigsetjmp(gBrokenDataJmp, 1);
503#else
504 sj = setjmp(gBrokenDataJmp);
505#endif /* HAVE_SIGSETJMP */
506
507 if (sj != 0) {
509 FTPShutdownHost(vcip);
512 }
513 gCanBrokenDataJmp = 1;
514
516 /* This line sets the buffer pointer so that the first thing
517 * BufferGets will do is reset and fill the buffer using
518 * real I/O.
519 */
520 secBufPtr = secondaryBuf + sizeof(secondaryBuf);
521 secBufLimit = (char *) 0;
523
524 for (;;) {
528 nread = BufferGets(line, sizeof(line), cip->dataSocket, secondaryBuf, &secBufPtr, &secBufLimit, sizeof(secondaryBuf));
529 if (nread <= 0) {
530 if (nread < 0)
531 break;
532 if (blankLines != 0)
534 } else {
536
537 if ((line[0] == '.') && ((line[1] == '\0') || ((line[1] == '.') && ((line[2] == '\0') || (iscntrl(line[2]))))))
538 continue; /* Skip . and .. */
539
541 }
542 }
544 (void) alarm(0);
549 }
551 cip->numListings++;
555 }
557#endif /* NO_SIGNALS */
559} /* FTPListToMemory2 */
_Check_return_ _CRTIMP int __cdecl iscntrl(_In_ int _C)
int sigsetjmp(sigjmp_buf buf, int savesigs)
Definition: tnmain.cpp:425
Referenced by FTPFileExistsNlst(), FTPFileExistsStat(), FTPListToMemory(), FTPRemoteGlob(), FTPRemoteRecursiveFileList(), FTPRemoteRecursiveFileList1(), Ls(), and MlsCmd().
◆ FTPLocalGlob()
Definition at line 1580 of file glob.c.
1581{
1582 string pattern2;
1584
1589
1592 InitLineList(fileList);
1593
1596
1598
1599 /* Pre-process for ~'s. */
1601 InitLineList(fileList);
1603
1605#if defined(WIN32) || defined(_WINDOWS)
1606 result = WinLocalGlob(cip, fileList, pattern2);
1607#else
1609#endif
1610 } else {
1611 /* Or, if there were no globbing characters in 'pattern', then
1612 * the pattern is really just a single pathname.
1613 */
1615 }
1616
1618} /* FTPLocalGlob */
static int LazyUnixLocalGlob(FTPCIPtr cip, LineListPtr fileList, const char *const pattern)
Definition: glob.c:1539
Referenced by EchoCmd(), FTPPutFiles3(), LocalRmCmd(), LocalRmdirCmd(), and SpoolPutCmd().
◆ FTPLocalRecursiveFileList()
| int FTPLocalRecursiveFileList | ( | FTPCIPtr | cip, |
| LineListPtr | fileList, | ||
| FileInfoListPtr | files | ||
| ) |
Definition at line 1333 of file glob.c.
1334{
1336} /* FTPLocalRecursiveFileList */
int FTPLocalRecursiveFileList2(FTPCIPtr cip, LineListPtr fileList, FileInfoListPtr files, int erelative)
Definition: glob.c:1276
Referenced by FTPPutFiles3().
◆ FTPLocalRecursiveFileList2()
| int FTPLocalRecursiveFileList2 | ( | FTPCIPtr | cip, |
| LineListPtr | fileList, | ||
| FileInfoListPtr | files, | ||
| int | erelative | ||
| ) |
Definition at line 1276 of file glob.c.
1277{
1278 LinePtr filePtr, nextFilePtr;
1279#if defined(WIN32) || defined(_WINDOWS)
1282#else
1283 char fullpath[512];
1284 char relpath[512];
1285#endif
1287 FileInfo fi;
1289
1290 InitFileInfoList(files);
1291
1293 filePtr != NULL;
1294 filePtr = nextFilePtr)
1295 {
1296 nextFilePtr = filePtr->next;
1297
1303 else
1307 continue;
1308 }
1309
1311 fi.relname = StrDup(relpath);
1312 fi.rname = NULL;
1313 fi.lname = StrDup(fullpath);
1314 fi.mdtm = st.st_mtime;
1315 fi.size = (longest_int) st.st_size;
1316 fi.rlinkto = NULL;
1317 fi.plug = NULL;
1318 fi.type = '-';
1320 continue; /* wasn't a directory */
1321 }
1322
1323 /* Paths collected must be relative. */
1324 Traverse(cip, fullpath, &st, relpath, files);
1325 }
1327} /* FTPLocalRecursiveFileList */
static void Traverse(FTPCIPtr cip, char *fullpath, struct Stat *st, char *relpath, FileInfoListPtr filp)
Definition: glob.c:1184
Referenced by FTPLocalRecursiveFileList().
◆ FTPLoginHost()
Definition at line 110 of file open.c.
111{
112 ResponsePtr rp;
114 int anonLogin;
115 int sentpass = 0;
116 int fwloggedin;
117 int firstTime;
118 char cwd[512];
119
124
127
128 anonLogin = 0;
132 anonLogin = 1;
133 /* Try to get the email address if you didn't specify
134 * a password when the user is anonymous.
135 */
139 }
140 }
141
142 rp = InitResponse();
146 goto done2;
147 }
148
149 for (firstTime = 1, fwloggedin = 0; ; ) {
150 /* Here's a mini finite-automaton for the login process.
151 *
152 * Originally, the FTP protocol was designed to be entirely
153 * implementable from a FA. It could be done, but I don't think
154 * it's something an interactive process could be the most
155 * effective with.
156 */
157
158 if (firstTime != 0) {
159 rp->code = 220;
160 firstTime = 0;
162 goto done;
163 }
164
166 case 220: /* Welcome, ready for new user. */
168 ReInitResponse(cip, rp);
171 ReInitResponse(cip, rp);
174 ReInitResponse(cip, rp);
177 ReInitResponse(cip, rp);
180 /* only reached when !fwloggedin */
181 ReInitResponse(cip, rp);
184 ReInitResponse(cip, rp);
186 } else {
188 }
189 break;
190
191 case 230: /* 230 User logged in, proceed. */
192 case 231: /* User name accepted. */
193 case 202: /* Command not implemented, superfluous at this site. */
195 goto okay;
196
197 /* Now logged in to the firewall. */
198 fwloggedin++;
199
201 ReInitResponse(cip, rp);
204 goto okay;
206 ReInitResponse(cip, rp);
209 ReInitResponse(cip, rp);
212 /* only reached when !fwloggedin */
213 ReInitResponse(cip, rp);
215 } else /* kFirewallUserAtSite */ {
216 goto okay;
217 }
218 break;
219
220 case 421: /* 421 Service not available, closing control connection. */
222 goto done;
223
224 case 331: /* 331 User name okay, need password. */
228 ReInitResponse(cip, rp);
231 ReInitResponse(cip, rp);
234 ReInitResponse(cip, rp);
237 ReInitResponse(cip, rp);
240 /* only reached when !fwloggedin */
241 ReInitResponse(cip, rp);
244 ReInitResponse(cip, rp);
246 } else {
248 }
249 sentpass++;
250 break;
251
252 case 332: /* 332 Need account for login. */
253 case 532: /* 532 Need account for storing files. */
255 ReInitResponse(cip, rp);
258 ReInitResponse(cip, rp);
260 } else {
261 /* ACCT not supported on firewall. */
263 }
264 break;
265
266 case 530: /* Not logged in. */
268 goto done;
269
270 case 501: /* Syntax error in parameters or arguments. */
271 case 503: /* Bad sequence of commands. */
272 case 550: /* Can't set guest privileges. */
273 goto done;
274
275 default:
276 unknown:
279 } else {
282 );
283 }
284 goto done;
285 }
286 }
287
288okay:
289 /* Do the application's connect message callback, if present. */
291 (*cip->onLoginMsgProc)(cip, rp);
292 DoneWithResponse(cip, rp);
293 result = 0;
294 cip->loggedIn = 1;
295
296 /* Make a note of what our root directory is.
297 * This is often different from "/" when not
298 * logged in anonymously.
299 */
303 }
306 {
308 }
309
310 /* When a new site is opened, ASCII mode is assumed (by protocol). */
313
314 /* Don't leave cleartext password in memory. */
317
321
322done:
323 DoneWithResponse(cip, rp);
324
325done2:
326 /* Don't leave cleartext password in memory. */
332} /* FTPLoginHost */
int doNotGetStartingWorkingDirectory
Definition: ncftp.h:237
Referenced by FTPOpenHost().
◆ FTPMkdir()
Definition at line 641 of file cmds.c.
642{
644} /* FTPMkdir */
int FTPMkdir2(const FTPCIPtr cip, const char *const newDir, const int recurse, const char *const curDir)
Definition: cmds.c:472
Referenced by FTPChdir3(), FTPPutFiles3(), and MkdirCmd().
◆ FTPMkdir2()
| int FTPMkdir2 | ( | const FTPCIPtr | cip, |
| const char *const | newDir, | ||
| const int | recurse, | ||
| const char *const | curDir | ||
| ) |
Definition at line 472 of file cmds.c.
473{
477 char dir2[512];
479
484
488 }
489
490 /* Preserve old working directory. */
492 /* This hack is nice so you can eliminate an
493 * unnecessary "PWD" command on the server,
494 * since if you already knew what directory
495 * you're in. We want to minimize the number
496 * of client-server exchanges when feasible.
497 */
499 }
500
503 /* Directory already exists -- but we
504 * must now change back to where we were.
505 */
507 if (result2 < 0) {
511 }
512
513 /* Don't need to create it. */
515 }
516
525 } else {
527 }
528 }
529 } else {
531
532 /* Strip trailing slashes. */
534 for (;;) {
540 }
541 }
544 break;
545 }
546 --cp;
547 }
549
551 /* Special case "mkdir /subdir" */
555 }
561 }
562 /* Haven't chdir'ed, don't need to goto goback. */
564 }
565
566 for (;;) {
576 }
577 /* Note: below we will refer to cp + 1
578 * which is why we set cp to point to
579 * the byte before the array begins!
580 */
582 break;
583 }
588 }
592 break; /* Found a valid parent dir. */
593 /* from this point, we need to preserve old dir. */
594 }
595 }
596
599 cp2 = cp;
608 /* Done, if they did "mkdir /tmp/dir/" */
609 break;
610 }
611 }
615 }
617 Error(cip, kDontPerror, "Cwd=%s; MKD %s failed; [%s]\n", cip->buf, newTreeStart, cip->lastFTPCmdResultStr);
620 goto goback;
621 }
623 break; /* No more to make, done. */
625 }
627
628goback:
633 }
634 }
636} /* FTPMkdir2 */
Referenced by FTPMkdir().
◆ FTPMListOneFile()
Definition at line 947 of file cmds.c.
948{
950 ResponsePtr rp;
951
952 /* We do a special check for older versions of NcFTPd which
953 * are based off of an incompatible previous version of IETF
954 * extensions.
955 *
956 * Roxen also seems to be way outdated, where MLST was on the
957 * data connection among other things.
958 *
959 */
960 if (
964 ) {
967 }
968
969 rp = InitResponse();
973 } else {
975 if (
976 (result == 2) &&
980 ) {
984 }
989 } else {
992 }
993 DoneWithResponse(cip, rp);
994 }
995
997} /* FTPMListOneFile */
Referenced by FTPFileExists2(), FTPFileSizeAndModificationTime(), and FTPFileType().
◆ FTPOpenHost()
Definition at line 818 of file open.c.
819{
821 time_t t0, t1;
822 int elapsed;
823 int dials;
824
829
833 }
834
837 dials++)
838 {
839 /* Allocate (or if the host was closed, reallocate)
840 * the transfer data buffer.
841 */
845
846 if (dials > 0)
854 /* We were hooked up successfully. */
856
860 break;
861 }
862
863 /* Close and try again. */
865
866 /* Originally we also stopped retyring if
867 * we got kErrBadRemoteUser and non-anonymous,
868 * but some FTP servers apparently do their
869 * max user check after the username is sent.
870 */
873 /* Non-anonymous login was denied, and
874 * retrying is not going to help.
875 */
876 break;
877 }
878 }
879 } else if ((result != kErrConnectRetryableErr) && (result != kErrConnectRefused) && (result != kErrRemoteHostClosedConnection)) {
880 /* Irrecoverable error, so don't bother redialing.
881 * The error message should have already been printed
882 * from OpenControlConnection().
883 */
886 }
887
888 /* Retryable error, wait and then redial. */
890 /* But don't sleep if this is the last loop. */
892 elapsed = (int) (t1 - t0);
893 if (elapsed < cip->redialDelay) {
899 }
900 }
901 }
902 }
904} /* FTPOpenHost */
int OpenControlConnection(const FTPCIPtr cip, char *host, unsigned int port)
Definition: ftp.c:347
Referenced by DoOpen().
◆ FTPOpenHostNoLogin()
Definition at line 910 of file open.c.
911{
913 time_t t0, t1;
914 int elapsed;
915 int dials;
916
921
925 }
926
929 dials++)
930 {
931
932 /* Allocate (or if the host was closed, reallocate)
933 * the transfer data buffer.
934 */
938
939 if (dials > 0)
947 /* We were hooked up successfully. */
949
950 /* Not logging in... */
952 break;
953 } else if ((result != kErrConnectRetryableErr) && (result != kErrConnectRefused) && (result != kErrRemoteHostClosedConnection)) {
954 /* Irrecoverable error, so don't bother redialing.
955 * The error message should have already been printed
956 * from OpenControlConnection().
957 */
960 }
961
962 /* Retryable error, wait and then redial. */
964 /* But don't sleep if this is the last loop. */
966 elapsed = (int) (t1 - t0);
967 if (elapsed < cip->redialDelay) {
973 }
974 }
975 }
976 }
978} /* FTPOpenHostNoLogin */
◆ FTPPerror()
| void FTPPerror | ( | const FTPCIPtr | cip, |
| const int | err, | ||
| const int | eerr, | ||
| const char *const | s1, | ||
| const char *const | s2 | ||
| ) |
Definition at line 134 of file errno.c.
135{
141 } else {
143 }
146 } else {
148 }
149 } else {
153 } else {
155 }
158 } else {
160 }
161 }
162 }
163} /* FTPPerror */
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
struct S1 s1
struct S2 s2
Referenced by CatCmd(), ChdirCmd(), ChmodCmd(), DeleteCmd(), DoOpen(), EchoCmd(), GetCmd(), LocalRmCmd(), LocalRmdirCmd(), MkdirCmd(), MlsCmd(), OpenCmd(), OpenURL(), PageCmd(), PutCmd(), PwdCmd(), RenameCmd(), RGlobCmd(), RmdirCmd(), RmtHelpCmd(), SpoolGetCmd(), SpoolPutCmd(), SymlinkCmd(), TypeCmd(), and UmaskCmd().
◆ FTPPutFiles()
| int FTPPutFiles | ( | const FTPCIPtr | cip, |
| const char *const | pattern, | ||
| const char *const | dstdir, | ||
| const int | recurse, | ||
| const int | doGlob | ||
| ) |
Definition at line 2784 of file io.c.
2785{
2786 return (FTPPutFiles3(cip, pattern, dstdir, recurse, doGlob, kTypeBinary, 0, NULL, NULL, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
2787} /* FTPPutFiles */
int FTPPutFiles3(const FTPCIPtr cip, const char *const pattern, const char *const dstdir1, const int recurse, const int doGlob, const int xtype, int appendflag, const char *const tmppfx, const char *const tmpsfx, const int resumeflag, const int deleteflag, const ConfirmResumeUploadProc resumeProc, int UNUSED(reserved))
Definition: io.c:1298
◆ FTPPutFiles2()
| int FTPPutFiles2 | ( | const FTPCIPtr | cip, |
| const char *const | pattern, | ||
| const char *const | dstdir, | ||
| const int | recurse, | ||
| const int | doGlob, | ||
| const int | xtype, | ||
| const int | appendflag, | ||
| const char *const | tmppfx, | ||
| const char *const | tmpsfx | ||
| ) |
Definition at line 2793 of file io.c.
2794{
2795 return (FTPPutFiles3(cip, pattern, dstdir, recurse, doGlob, xtype, appendflag, tmppfx, tmpsfx, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
2796} /* FTPPutFiles2 */
◆ FTPPutFiles3()
| int FTPPutFiles3 | ( | const FTPCIPtr | cip, |
| const char *const | pattern, | ||
| const char *const | dstdir, | ||
| const int | recurse, | ||
| const int | doGlob, | ||
| const int | xtype, | ||
| int | appendflag, | ||
| const char *const | tmppfx, | ||
| const char *const | tmpsfx, | ||
| const int | resumeflag, | ||
| const int | deleteflag, | ||
| const ConfirmResumeUploadProc | resumeProc, | ||
| int | reserved | ||
| ) |
◆ FTPPutFilesAscii()
| int FTPPutFilesAscii | ( | const FTPCIPtr | cip, |
| const char *const | pattern, | ||
| const char *const | dstdir, | ||
| const int | recurse, | ||
| const int | doGlob | ||
| ) |
Definition at line 2811 of file io.c.
2812{
2813 return (FTPPutFiles3(cip, pattern, dstdir, recurse, doGlob, kTypeAscii, 0, NULL, NULL, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
2814} /* FTPPutFilesAscii */
◆ FTPPutOneFile()
Definition at line 2766 of file io.c.
2767{
2768 return (FTPPutOneFile3(cip, file, dstfile, kTypeBinary, -1, 0, NULL, NULL, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
2769} /* FTPPutOneFile */
int FTPPutOneFile3(const FTPCIPtr cip, const char *const file, const char *const dstfile, const int xtype, const int fdtouse, const int appendflag, const char *const tmppfx, const char *const tmpsfx, const int resumeflag, const int deleteflag, const ConfirmResumeUploadProc resumeProc, int UNUSED(reserved))
Definition: io.c:1262
◆ FTPPutOneFile2()
| int FTPPutOneFile2 | ( | const FTPCIPtr | cip, |
| const char *const | file, | ||
| const char *const | dstfile, | ||
| const int | xtype, | ||
| const int | fdtouse, | ||
| const int | appendflag, | ||
| const char *const | tmppfx, | ||
| const char *const | tmpsfx | ||
| ) |
Definition at line 2775 of file io.c.
2776{
2777 return (FTPPutOneFile3(cip, file, dstfile, xtype, fdtouse, appendflag, tmppfx, tmpsfx, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
2778} /* FTPPutOneFile2 */
◆ FTPPutOneFile3()
| int FTPPutOneFile3 | ( | const FTPCIPtr | cip, |
| const char *const | file, | ||
| const char *const | dstfile, | ||
| const int | xtype, | ||
| const int | fdtouse, | ||
| const int | appendflag, | ||
| const char *const | tmppfx, | ||
| const char *const | tmpsfx, | ||
| const int | resumeflag, | ||
| const int | deleteflag, | ||
| const ConfirmResumeUploadProc | resumeProc, | ||
| int | reserved | ||
| ) |
◆ FTPPutOneFileAscii()
Definition at line 2802 of file io.c.
2803{
2804 return (FTPPutOneFile3(cip, file, dstfile, kTypeAscii, -1, 0, NULL, NULL, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
2805} /* FTPPutOneFileAscii */
◆ FTPQueryFeatures()
Definition at line 380 of file open.c.
381{
382 ResponsePtr rp;
384 LinePtr lp;
386
391
393 /* NetWare 5.00 server freaks out when
394 * you give it a command it doesn't
395 * recognize, so cheat here and return.
396 */
397 cip->hasPASV = kCommandAvailable;
398 cip->hasSIZE = kCommandNotAvailable;
399 cip->hasMDTM = kCommandNotAvailable;
400 cip->hasREST = kCommandNotAvailable;
401 cip->NLSTfileParamWorks = kCommandAvailable;
402 cip->hasUTIME = kCommandNotAvailable;
403 cip->hasCLNT = kCommandNotAvailable;
404 cip->hasMLST = kCommandNotAvailable;
405 cip->hasMLSD = kCommandNotAvailable;
407 }
408
409 rp = InitResponse();
411 cip->errNo = kErrMallocFailed;
412 result = cip->errNo;
413 } else {
417 DoneWithResponse(cip, rp);
420 /* We cheat here and pre-populate some
421 * fields when the server is wu-ftpd.
422 * This server is very common and we
423 * know it has always had these.
424 */
426 cip->hasPASV = kCommandAvailable;
427 cip->hasSIZE = kCommandAvailable;
428 cip->hasMDTM = kCommandAvailable;
429 cip->hasREST = kCommandAvailable;
430 cip->NLSTfileParamWorks = kCommandAvailable;
432 cip->hasPASV = kCommandAvailable;
433 cip->hasSIZE = kCommandAvailable;
434 cip->hasMDTM = kCommandAvailable;
435 cip->hasREST = kCommandAvailable;
436 cip->NLSTfileParamWorks = kCommandAvailable;
437 }
438
439 /* Newer commands are only shown in FEAT,
440 * so we don't have to do the "try it,
441 * then save that it didn't work" thing.
442 */
443 cip->hasMLST = kCommandNotAvailable;
444 cip->hasMLSD = kCommandNotAvailable;
445 } else {
446 cip->hasFEAT = kCommandAvailable;
447
449 /* If first character was not a space it is
450 * either:
451 *
452 * (a) The header line in the response;
453 * (b) The trailer line in the response;
454 * (c) A protocol violation.
455 */
458 continue;
460 cip->hasPASV = kCommandAvailable;
462 cip->hasSIZE = kCommandAvailable;
464 cip->hasMDTM = kCommandAvailable;
466 cip->hasREST = kCommandAvailable;
468 cip->hasUTIME = kCommandAvailable;
470 cip->hasMLST = kCommandAvailable;
471 cip->hasMLSD = kCommandAvailable;
474 cip->hasCLNT = kCommandAvailable;
476 /* Probably only NcFTPd will ever implement this.
477 * But we use it internally to differentiate
478 * between different NcFTPd implementations of
479 * IETF extensions.
480 */
482 }
483 }
484 }
485
486 ReInitResponse(cip, rp);
492 cip->hasRETRBUFSIZE = kCommandAvailable;
494 cip->hasRBUFSZ = kCommandAvailable;
495 /* See if RBUFSIZ matches (but not STORBUFSIZE) */
496 if (
498 (
501 )
502 )
503 cip->hasRBUFSIZ = kCommandAvailable;
505 cip->hasSTORBUFSIZE = kCommandAvailable;
507 cip->hasSBUFSIZ = kCommandAvailable;
509 cip->hasSBUFSZ = kCommandAvailable;
511 cip->hasBUFSIZE = kCommandAvailable;
512 }
513 }
514 DoneWithResponse(cip, rp);
515 }
516
518} /* FTPQueryFeatures */
static void FTPExamineMlstFeatures(const FTPCIPtr cip, const char *features)
Definition: open.c:338
Referenced by FTPOpenHost().
◆ FTPRebuildConnectionInfo()
Definition at line 1041 of file open.c.
1042{
1044
1045 cip->lip = lip;
1053 cip->errNo = 0;
1064
1066
1067 /* Allocate a new buffer. */
1072 }
1074
1075 /* Reattach the FILE pointers for use with the Std I/O library
1076 * routines.
1077 */
1083 }
1084
1091 }
1092
1093#if USE_SIO
1094 if (InitSReadlineInfo(&cip->ctrlSrl, cip->ctrlSocketR, cip->srlBuf, sizeof(cip->srlBuf), (int) cip->ctrlTimeout, 1) < 0) {
1101 }
1102#endif
1104} /* FTPRebuildConnectionInfo */
_Check_return_ _CRTIMP FILE *__cdecl _fdopen(_In_ int _FileHandle, _In_z_ const char *_Mode)
const char * asciiFilenameExtensions
Definition: ncftp.h:246
◆ FTPRemoteGlob()
Definition at line 1341 of file glob.c.
1342{
1344 const char *lsflags;
1345 LinePtr lp;
1347
1352
1355 InitLineList(fileList);
1356
1359
1360 /* Note that we do attempt to use glob characters even if the remote
1361 * host isn't UNIX. Most non-UNIX remote FTP servers look for UNIX
1362 * style wildcards.
1363 */
1365 /* Use NLST, which lists files one per line. */
1366 lsflags = "";
1367
1368 /* Optimize for "NLST *" case which is same as "NLST". */
1372 /* Hack; Lets you try "NLST -a" if you're daring. */
1374 lsflags = "-a";
1375 }
1376
1378 if (*lsflags == '\0')
1380 /* Try again, without "-a" */
1381 lsflags = "";
1384 }
1385 }
1389 }
1391#define glberr(a) (ISTRNEQ(cp, a, strlen(a)))
1392 /* If we have only one item in the list, see if it really was
1393 * an error message we would recognize.
1394 */
1404 }
1405 }
1406 }
1410 } else {
1411 /* Or, if there were no globbing characters in 'pattern', then the
1412 * pattern is really just a filename. So for this case the
1413 * file list is really just a single file.
1414 */
1417 }
1419} /* FTPRemoteGlob */
#define glberr(a)
static void RemoteGlobCollapse(const char *pattern, LineListPtr fileList)
Definition: glob.c:43
Referenced by ChdirCmd(), FTPChmod(), FTPDelete(), FTPFtwL2(), FTPGetFiles3(), FTPRmdir(), FTPRmdirRecursiveL2(), RGlobCmd(), and SpoolGetCmd().
◆ FTPRemoteHelp()
Definition at line 739 of file cmds.c.
740{
742 ResponsePtr rp;
743
748
749 InitLineList(llp);
750 rp = InitResponse();
753 cip->errNo = kErrMallocFailed;
755 } else {
758 else
761 DoneWithResponse(cip, rp);
766 cip->errNo = kErrMallocFailed;
768 } else {
770 }
771 } else {
772 cip->errNo = kErrHELPFailed;
774 }
775 DoneWithResponse(cip, rp);
776 }
778} /* FTPRemoteHelp */
Referenced by RmtHelpCmd().
◆ FTPRemoteRecursiveFileList()
| int FTPRemoteRecursiveFileList | ( | FTPCIPtr | cip, |
| LineListPtr | fileList, | ||
| FileInfoListPtr | files | ||
| ) |
Definition at line 1032 of file glob.c.
1033{
1034 LinePtr filePtr, nextFilePtr;
1035 LineList dirContents;
1036 FileInfoList fil;
1037 char cwd[512];
1039 char *rdir;
1040
1043
1044 InitFileInfoList(files);
1045
1047 filePtr != NULL;
1048 filePtr = nextFilePtr)
1049 {
1050 nextFilePtr = filePtr->next;
1051
1052 rdir = filePtr->line;
1054 continue;
1055
1057 /* Probably not a directory.
1058 * Just add it as a plain file
1059 * to the list.
1060 */
1062 continue;
1063 }
1064
1065 /* Paths collected must be relative. */
1067 goto goback;
1068 }
1069
1071 DisposeLineListContents(&dirContents);
1074 DisposeFileInfoListContents(&fil);
1075
1076goback:
1079 }
1080 }
1082} /* FTPRemoteRecursiveFileList */
int ConcatFileInfoList(FileInfoListPtr dst, FileInfoListPtr src)
Definition: linelist.c:556
int ConcatFileToFileInfoList(FileInfoListPtr dst, char *rfile)
Definition: linelist.c:740
int ComputeRNames(FileInfoListPtr dst, const char *dstdir, int pflag, int nochop)
Definition: linelist.c:579
void DisposeFileInfoListContents(FileInfoListPtr list)
Definition: linelist.c:152
◆ FTPRemoteRecursiveFileList1()
| int FTPRemoteRecursiveFileList1 | ( | FTPCIPtr | cip, |
| char * const | rdir, | ||
| FileInfoListPtr | files | ||
| ) |
Definition at line 983 of file glob.c.
984{
985 LineList dirContents;
986 FileInfoList fil;
987 char cwd[512];
989
992
993 InitFileInfoList(files);
994
996 return (-1);
997
999 /* Probably not a directory.
1000 * Just add it as a plain file
1001 * to the list.
1002 */
1005 }
1006
1007 /* Paths collected must be relative. */
1011 }
1012 }
1013
1015 DisposeLineListContents(&dirContents);
1016 /* Could sort it to breadth-first here. */
1017 /* (void) SortRecursiveFileList(&fil); */
1020 DisposeFileInfoListContents(&fil);
1021
1024 }
1026} /* FTPRemoteRecursiveFileList1 */
Referenced by FTPGetFiles3().
◆ FTPRename()
Definition at line 703 of file cmds.c.
704{
706
715
716
723 }
724
731 }
733} /* FTPRename */
Referenced by FTPPutOneF(), and RenameCmd().
◆ FTPRmdir()
Definition at line 784 of file cmds.c.
785{
786 LineList fileList;
787 LinePtr filePtr;
789 int onceResult, batchResult;
790
795
798 return (batchResult);
799
801 filePtr != NULL;
802 filePtr = filePtr->next)
803 {
806 batchResult = kErrBadLineList;
808 break;
809 }
811 if (onceResult < 0) {
812 batchResult = onceResult;
813 break;
814 }
815 if (onceResult != 2) {
818 if (onceResult < 0) {
819 batchResult = kErrRMDFailed;
821 }
822 } else {
823 batchResult = kErrRMDFailed;
825 }
826 }
827 }
828 DisposeLineListContents(&fileList);
829 return (batchResult);
830} /* FTPRmdir */
Referenced by FTPRmdirRecursive(), FTPRmdirRecursiveL2(), and RmdirCmd().
◆ FTPSetTransferType()
Definition at line 836 of file cmds.c.
837{
839
844
850 break;
851 case 'i':
852 case 'b':
853 case 'B':
855 break;
856 case 'e':
858 break;
859 case 'a':
861 break;
862 default:
863 /* Yeah, we don't support Tenex. Who cares? */
865 cip->errNo = kErrBadTransferType;
867 }
871 cip->errNo = kErrTYPEFailed;
873 }
874 cip->curTransferType = type;
875 }
877} /* FTPSetTransferType */
Referenced by FTPFileSize(), FTPFileSizeAndModificationTime(), FTPGetOneF(), FTPPutOneF(), FTPStartDataCmd(), and TypeCmd().
◆ FTPShutdownHost()
Definition at line 564 of file open.c.
565{
566#ifdef SIGPIPE
567 FTPSigProc osigpipe;
568#endif
569
571 return;
573 return;
574
575#ifdef SIGPIPE
577#endif
578
579 /* Linger could cause close to block, so unset it. */
583
584 /* Linger should already be turned off for this. */
585 CloseControlConnection(cip);
586
587 FTPDeallocateHost(cip);
588
589#ifdef SIGPIPE
591#endif
592} /* FTPShutdownHost */
Referenced by CommandShell(), FTPGetOneF(), FTPListToMemory2(), FTPPutOneF(), and GetResponse().
◆ FTPStartDataCmd()
| int FTPStartDataCmd | ( | const | FTPCIPtr, |
| int | netMode, | ||
| int | type, | ||
| longest_int | startPoint, | ||
| const char * | cmdspec, | ||
| ... | |||
| ) |
Definition at line 763 of file rcmd.c.
764{
767 int respCode;
768 ResponsePtr rp;
769
774
778
779 /* Re-set the cancellation flag. */
780 cip->cancelXfer = 0;
781
782 /* To transfer data, we do these things in order as specifed by
783 * the RFC.
784 *
785 * First, we tell the other side to set up a data line. This
786 * is done below by calling OpenDataConnection(), which sets up
787 * the socket. When we do that, the other side detects a connection
788 * attempt, so it knows we're there. Then tell the other side
789 * (by using listen()) that we're willing to receive a connection
790 * going to our side.
791 */
792
794 goto done;
795
796 /* If asked, attempt to start at a later position in the remote file. */
799 startPoint = (longest_int) 0;
800 }
801 cip->startPoint = startPoint;
802
803 /* Now we tell the server what we want to do. This sends the
804 * the type of transfer we want (RETR, STOR, LIST, etc) and the
805 * parameters for that (files to send, directories to list, etc).
806 */
808#ifndef NO_SIGNALS
809 if (cip->ctrlTimeout > 0)
810 (void) alarm(cip->ctrlTimeout);
811#endif /* NO_SIGNALS */
815#ifndef NO_SIGNALS
816 if (cip->ctrlTimeout > 0)
817 (void) alarm(0);
818#endif /* NO_SIGNALS */
819 goto done;
820 }
821
822 /* Get the response to the transfer command we sent, to see if
823 * they can accomodate the request. If everything went okay,
824 * we will get a preliminary response saying that the transfer
825 * initiation was successful and that the data is there for
826 * reading (for retrieves; for sends, they will be waiting for
827 * us to send them something).
828 */
829 rp = InitResponse();
832 cip->errNo = kErrMallocFailed;
833 result = cip->errNo;
834 goto done;
835 }
837#ifndef NO_SIGNALS
838 if (cip->ctrlTimeout > 0)
839 (void) alarm(0);
840#endif /* NO_SIGNALS */
841
843 goto done;
844 respCode = rp->codeType;
845 DoneWithResponse(cip, rp);
846
847 if (respCode > 2) {
848 cip->errNo = kErrCouldNotStartDataTransfer;
849 result = cip->errNo;
850 goto done;
851 }
852
853 /* Now we accept the data connection that the other side is offering
854 * to us. Then we can do the actual I/O on the data we want.
855 */
856 cip->netMode = netMode;
858 goto done;
860
861done:
864} /* FTPStartDataCmd */
Referenced by FTPGetOneF(), FTPList(), FTPListToMemory2(), and FTPPutOneF().
◆ FTPStartIOTimer()
Definition at line 93 of file io.c.
Referenced by FTPGetOneF(), and FTPPutOneF().
◆ FTPStopIOTimer()
Definition at line 159 of file io.c.
160{
161 cip->nextProgressUpdate = 0; /* force last update */
162 FTPUpdateIOTimer(cip);
164 (*cip->progress)(cip, kPrEndMsg);
165} /* FTPStopIOTimer */
Referenced by FTPGetOneF(), and FTPPutOneF().
◆ FTPStrError()
Definition at line 114 of file errno.c.
115{
117 return ("miscellaneous error");
119 return ("no error");
120 } else {
125 }
126 }
127 return ("unrecognized error number");
128} /* FTPStrError */
Referenced by FTPPerror(), FTPPutOneF(), InitConnectionInfo(), and PreInit().
◆ FTPSymlink()
Definition at line 1585 of file cmds.c.
1586{
1591 if ((lfrom[0] == '\0') || (lto[0] == '\0'))
1596} /* FTPSymlink */
Referenced by FTPPutFiles3(), and SymlinkCmd().
◆ FTPUmask()
◆ FTPUpdateIOTimer()
Definition at line 104 of file io.c.
105{
106 double sec;
109
111 if (now < cip->nextProgressUpdate)
112 return;
113 now += 1;
114 cip->nextProgressUpdate = now;
115
117 t0 = &cip->t0;
118
120 t1.tv_usec += 1000000;
121 t1.tv_sec--;
122 }
125 if (sec > 0.0) {
126 cip->kBytesPerSec = ((double) cip->bytesTransferred) / (1024.0 * sec);
127 } else {
128 cip->kBytesPerSec = -1.0;
129 }
131 cip->percentCompleted = -1.0;
132 cip->secLeft = -1.0;
133 } else if (cip->expectedSize <= 0) {
134 cip->percentCompleted = 100.0;
135 cip->secLeft = 0.0;
136 } else {
137 cip->percentCompleted = ((double) (100.0 * (cip->bytesTransferred + cip->startPoint))) / ((double) cip->expectedSize);
138 if (cip->percentCompleted >= 100.0) {
139 cip->percentCompleted = 100.0;
140 cip->secLeft = 0.0;
141 } else if (cip->percentCompleted <= 0.0) {
142 cip->secLeft = 999.0;
143 }
144 if (cip->kBytesPerSec > 0.0) {
145 cip->secLeft = ((cip->expectedSize - cip->bytesTransferred - cip->startPoint) / 1024.0) / cip->kBytesPerSec;
146 if (cip->secLeft < 0.0)
147 cip->secLeft = 0.0;
148 }
149 }
150 cip->sec = sec;
152 (*cip->progress)(cip, kPrUpdateMsg);
153} /* FTPUpdateIOTimer */
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
Definition: linux.h:1737
Referenced by FTPGetOneF(), FTPPutOneF(), FTPStopIOTimer(), WaitForRemoteInput(), and WaitForRemoteOutput().
◆ FTPUtime()
| int FTPUtime | ( | const FTPCIPtr | cip, |
| const char *const | file, | ||
| time_t | actime, | ||
| time_t | modtime, | ||
| time_t | crtime | ||
| ) |
Definition at line 1649 of file cmds.c.
1650{
1651 char mstr[64], astr[64], cstr[64];
1653 ResponsePtr rp;
1654
1659
1663 } else {
1669 crtime = modtime;
1670
1674
1675 rp = InitResponse();
1680 } else {
1683 DoneWithResponse(cip, rp);
1692 } else {
1695 }
1696 DoneWithResponse(cip, rp);
1697 }
1698 }
1700} /* FTPUtime */
static void GmTimeStr(char *const dst, const size_t dstsize, time_t t)
Definition: cmds.c:1619
Referenced by FTPPutOneF().
◆ GetHomeDir()
Definition at line 240 of file util.c.
241{
242#if defined(WIN32) || defined(_WINDOWS)
243 const char *homedrive, *homepath;
244
250 return;
251 }
252
253// GetSpecialDir(dst, size, CSIDL_PERSONAL /* "My Documents" */);
254// if (dst[0] != '\0')
255// return;
256//
257// dst[0] = '\0';
258// if (GetWindowsDirectory(dst, size - 1) < 1)
259// (void) Strncpy(dst, ".", size);
260// else if (dst[1] == ':') {
261// dst[2] = '\\';
262// dst[3] = '\0';
263// }
264#else
266 struct passwd *pw;
267
268 pw = NULL;
269#if defined(USE_GETPWUID)
270 /* Try to use getpwuid(), but if we have to, fall back to getpwnam(). */
273#else
274 /* Try to use getpwnam(), but if we have to, fall back to getpwuid(). */
277#endif
279 cp = pw->pw_dir;
283#endif
284} /* GetHomeDir */
_Check_return_ char *__cdecl getenv(_In_z_ const char *_VarName)
Referenced by ExpandTilde().
◆ GetPass()
Definition at line 186 of file util.c.
187{
188#ifdef HAVE_GETPASS
190#elif defined(_CONSOLE) && (defined(WIN32) || defined(_WINDOWS))
191 static char pwbuf[128];
194
197 return (pwbuf);
200
204 /* The key is a function or arrow key; read and discard. */
206 }
208 break;
211 }
213
216 return (pwbuf);
217#else
218 static char pwbuf[128];
219
221#if defined(WIN32) || defined(_WINDOWS)
223#else
225#endif
226 return (pwbuf);
232 return (pwbuf);
233#endif
234} /* GetPass */
_Check_return_ _CRTIMP int __cdecl _fileno(_In_ FILE *_File)
_Check_return_opt_ _CRTIMP int __cdecl fputs(_In_z_ const char *_Str, _Inout_ FILE *_File)
_Check_return_opt_ _CRTIMP int __cdecl fflush(_Inout_opt_ FILE *_File)
_Check_return_ _CRTIMP int __cdecl _isatty(_In_ int _FileHandle)
Referenced by DECLARE_INTERFACE_().
◆ GetResponse()
| int GetResponse | ( | const | FTPCIPtr, |
| ResponsePtr | rp | ||
| ) |
Definition at line 287 of file rcmd.c.
288{
290 int eofError;
293 int continuation;
295#ifdef NO_SIGNALS
297#else /* NO_SIGNALS */
299 int sj;
300#endif /* NO_SIGNALS */
301
302 /* RFC 959 states that a reply may span multiple lines. A single
303 * line message would have the 3-digit code <space> then the msg.
304 * A multi-line message would have the code <dash> and the first
305 * line of the msg, then additional lines, until the last line,
306 * which has the code <space> and last line of the msg.
307 *
308 * For example:
309 * 123-First line
310 * Second line
311 * 234 A line beginning with numbers
312 * 123 The last line
313 */
314
315#ifdef NO_SIGNALS
316 vcip = cip;
317#else /* NO_SIGNALS */
319 vcip = cip;
320
321#ifdef HAVE_SIGSETJMP
322 sj = sigsetjmp(gBrokenCtrlJmp, 1);
323#else
324 sj = setjmp(gBrokenCtrlJmp);
325#endif /* HAVE_SIGSETJMP */
326
327 if (sj != 0) {
329 FTPShutdownHost(vcip);
332 }
333#endif /* NO_SIGNALS */
334
335#ifdef NO_SIGNALS
337 eofError = 0;
338 if (cip->dataTimedOut > 0) {
339 /* Give up immediately unless the server had already
340 * sent a message. Odds are since the data is timed
341 * out, so is the control.
342 */
344 /* timeout */
346 FTPShutdownHost(vcip);
347 cip->errNo = kErrControlTimedOut;
348 return (cip->errNo);
349 }
350 }
353 /* timeout */
355 FTPShutdownHost(vcip);
356 cip->errNo = kErrControlTimedOut;
357 return (cip->errNo);
359 /* eof */
360 eofError = 1;
361 rp->hadEof = 1;
364 FTPShutdownHost(vcip);
365 cip->errNo = kErrRemoteHostClosedConnection;
366 return (cip->errNo);
368 /* error */
370 FTPShutdownHost(vcip);
371 cip->errNo = kErrInvalidReplyFromServer;
372 return (cip->errNo);
373 }
374
377
378#else /* NO_SIGNALS */
379 /* Get the first line of the response. */
381
384 if (eofError < 0) {
385 /* No bytes read for reply, and EOF detected. */
386 rp->hadEof = 1;
389 FTPShutdownHost(vcip);
390 cip->errNo = kErrRemoteHostClosedConnection;
392 return(cip->errNo);
393 }
394 }
395#endif /* NO_SIGNALS */
396
399 cip->errNo = kErrInvalidReplyFromServer;
400#ifndef NO_SIGNALS
402#endif
403 return (cip->errNo);
404 }
405
407 cp += 3;
413 if (eofError < 0) {
414 /* Read reply, but EOF was there also. */
415 rp->hadEof = 1;
416 }
417
418 while (continuation) {
419
420#ifdef NO_SIGNALS
423 /* timeout */
425 FTPShutdownHost(vcip);
426 cip->errNo = kErrControlTimedOut;
427 return (cip->errNo);
429 /* eof */
430 eofError = 1;
431 rp->hadEof = 1;
434 FTPShutdownHost(vcip);
435 cip->errNo = kErrRemoteHostClosedConnection;
436 return (cip->errNo);
438 /* error */
440 FTPShutdownHost(vcip);
441 cip->errNo = kErrInvalidReplyFromServer;
442 return (cip->errNo);
443 }
444
447#else /* NO_SIGNALS */
449 if (eofError < 0) {
450 /* Read reply, but EOF was there also. */
451 rp->hadEof = 1;
452 continuation = 0;
453 }
454#endif /* NO_SIGNALS */
457 cp += 3;
459 continuation = 0;
460 ++cp;
461 }
463 }
464
466 /*
467 * 421 Service not available, closing control connection.
468 * This may be a reply to any command if the service knows it
469 * must shut down.
470 */
473 FTPShutdownHost(vcip);
474 cip->errNo = kErrRemoteHostClosedConnection;
475#ifndef NO_SIGNALS
477#endif
478 return(cip->errNo);
479 }
480
481#ifndef NO_SIGNALS
483#endif
485} /* GetResponse */
int SWaitUntilReadyForReading(const int sfd, const int tlen)
Definition: SWait.c:7
int GetTelnetString(const FTPCIPtr, char *, size_t, FILE *, FILE *)
Definition: inflate.c:139
Referenced by FTPAbortDataTransfer(), FTPCmd(), FTPEndDataCmd(), FTPStartDataCmd(), OpenControlConnection(), and RCmd().
◆ GetTelnetString()
Referenced by GetResponse().
◆ GetUsrName()
Definition at line 290 of file util.c.
291{
292#if defined(WIN32) || defined(_WINDOWS)
293 DWORD size1;
294
295 size1 = size - 1;
299#else
301 struct passwd *pw;
302
303 pw = NULL;
304#ifdef USE_GETPWUID
305 /* Try to use getpwuid(), but if we have to, fall back to getpwnam(). */
308#else
309 /* Try to use getpwnam(), but if we have to, fall back to getpwuid(). */
312#endif
314 cp = pw->pw_name;
318#endif
319} /* GetUserName */
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
Referenced by FTPInitializeAnonPassword().
◆ InitFileInfo()
| void InitFileInfo | ( | FileInfoPtr | fip | ) |
Definition at line 471 of file linelist.c.
472{
477} /* InitFileInfoList */
Referenced by ConcatFileToFileInfoList().
◆ InitFileInfoList()
| void InitFileInfoList | ( | FileInfoListPtr | list | ) |
Definition at line 193 of file linelist.c.
Referenced by FTPLocalRecursiveFileList2(), FTPRemoteRecursiveFileList(), FTPRemoteRecursiveFileList1(), LineListToFileInfoList(), LineToFileInfoList(), Ls(), UnLslR(), and UnMlsD().
◆ InitLineList()
| void InitLineList | ( | LineListPtr | list | ) |
Definition at line 54 of file linelist.c.
Referenced by ChdirCmd(), CopyLineList(), EchoCmd(), FTPDecodeURL(), FTPFileExistsNlst(), FTPListToMemory2(), FTPLocalGlob(), FTPRemoteGlob(), FTPRemoteHelp(), InitResponse(), LocalRmCmd(), LocalRmdirCmd(), Ls(), OpenCmd(), PreInit(), RGlobCmd(), SpoolGetCmd(), and SpoolPutCmd().
◆ InitResponse()
| ResponsePtr InitResponse | ( | void | ) |
Definition at line 38 of file rcmd.c.
Referenced by FTPAbortDataTransfer(), FTPChdirAndGetCWD(), FTPCloseHost(), FTPCmd(), FTPEndDataCmd(), FTPFileExistsStat(), FTPFileModificationTime(), FTPFileSize(), FTPGetCWD(), FTPLoginHost(), FTPMListOneFile(), FTPQueryFeatures(), FTPRemoteHelp(), FTPStartDataCmd(), FTPUtime(), nFTPChdirAndGetCWD(), OpenControlConnection(), Passive(), SendPort(), and SetStartOffset().
◆ LineListToFileInfoList()
| int LineListToFileInfoList | ( | LineListPtr | src, |
| FileInfoListPtr | dst | ||
| ) |
Definition at line 758 of file linelist.c.
759{
760 LinePtr lp, lp2;
761
764 lp2 = lp->next;
766 return (-1);
767 }
768 return (0);
769} /* LineListToFileList */
Referenced by FTPPutFiles3().
◆ LineToFileInfoList()
| int LineToFileInfoList | ( | LinePtr | lp, |
| FileInfoListPtr | dst | ||
| ) |
Definition at line 775 of file linelist.c.
776{
779 return (-1);
780 return (0);
781} /* LineToFileInfoList */
Referenced by FTPGetFiles3().
◆ MkDirs()
Definition at line 785 of file util.c.
786{
788 int rc;
790#if defined(WIN32) || defined(_WINDOWS)
792 char *share;
793#else
796#endif
797
798#if defined(WIN32) || defined(_WINDOWS)
801 /* Special case "c:blah", and errout.
802 * "c:\blah" must be used or _access GPFs.
803 */
805 return (-1);
806 } else if (newdir[3] == '\0') {
807 /* Special case root directory, which cannot be made. */
808 return (0);
809 }
811 share = StrFindLocalPathDelim(newdir + 2);
813 return (-1);
814 }
815
818 return (-1);
821 return (-1);
822 }
823 return 0;
824 }
825#else
828 return (-1);
831 return (-1);
832 }
833 return 0;
834 }
835#endif
836
839#ifdef ENAMETOOLONG
841#else
843 return (-1);
844#endif
845 }
846
849#if defined(WIN32) || defined(_WINDOWS)
851 return (-1);
852 return (0);
853#else
855 return (rc);
856#endif
858 /* Remove trailing slashes from path. */
859 --cp;
862 break;
863 --cp;
864 }
868#if defined(WIN32) || defined(_WINDOWS)
870 return (-1);
871#else
873 return (rc);
874#endif
875 }
876 }
877
878 /* Find the deepest directory in this
879 * path that already exists. When
880 * we do, we want to have the 's'
881 * string as it was originally, but
882 * with 'cp' pointing to the first
883 * slash in the path that starts the
884 * part that does not exist.
885 */
886 sl = NULL;
887 for (;;) {
889#if defined(WIN32) || defined(_WINDOWS)
891#else
893#endif
895 *sl = LOCAL_PATH_DELIM;
896 if (rc == 0) {
898 break;
899 }
900 sl = cp;
903 /* We do not have any more
904 * slashes, so none of the
905 * new directory's components
906 * existed before, so we will
907 * have to make everything
908 * starting at the first node.
909 */
911 *sl = LOCAL_PATH_DELIM;
912
913 /* We refer to cp + 1 below,
914 * so this is why we can
915 * set "cp" to point to the
916 * byte before the array starts.
917 */
919 break;
920 }
921 }
922
923 for (;;) {
924 /* Extend the path we have to
925 * include the next component
926 * to make.
927 */
930 /* If the next slash is pointing
931 * to the start of the string, then
932 * the path is an absolute path and
933 * we don't need to make the root node,
934 * and besides the next mkdir would
935 * try an empty string.
936 */
937 ++cp;
939 }
941 *sl = '\0';
942 }
943#if defined(WIN32) || defined(_WINDOWS)
945 return (-1);
946#else
948 if (rc < 0)
949 return rc;
950#endif
952 break;
953 *sl = LOCAL_PATH_DELIM;
954 cp = sl;
955 }
956 return (0);
957} /* MkDirs */
_Check_return_ _CRTIMP int __cdecl _access(_In_z_ const char *_Filename, _In_ int _AccessMode)
Definition: compat.h:191
Referenced by FTPGetFiles3(), InitOurDirectory(), LocalMkdirCmd(), and MkSpoolDir().
◆ PrintResponse()
| void PrintResponse | ( | const | FTPCIPtr, |
| LineListPtr | llp | ||
| ) |
◆ RCmd()
| int RCmd | ( | const | FTPCIPtr, |
| ResponsePtr | rp, | ||
| const char * | cmdspec, | ||
| ... | |||
| ) |
Definition at line 718 of file rcmd.c.
719{
722
727
729#ifndef NO_SIGNALS
730 if (cip->ctrlTimeout > 0)
731 (void) alarm(cip->ctrlTimeout);
732#endif /* NO_SIGNALS */
736#ifndef NO_SIGNALS
737 if (cip->ctrlTimeout > 0)
738 (void) alarm(0);
739#endif /* NO_SIGNALS */
741 }
742
743 /* Get the response to the command we sent. */
745#ifndef NO_SIGNALS
746 if (cip->ctrlTimeout > 0)
747 (void) alarm(0);
748#endif /* NO_SIGNALS */
749
753} /* RCmd */
Referenced by FTPChdirAndGetCWD(), FTPCloseHost(), FTPFileExistsStat(), FTPFileModificationTime(), FTPFileSize(), FTPGetCWD(), FTPLoginHost(), FTPMListOneFile(), FTPQueryFeatures(), FTPRemoteHelp(), FTPUtime(), nFTPChdirAndGetCWD(), Passive(), SendPort(), and SetStartOffset().
◆ ReInitResponse()
| void ReInitResponse | ( | const | FTPCIPtr, |
| ResponsePtr | rp | ||
| ) |
Definition at line 142 of file rcmd.c.
143{
145 TraceResponse(cip, rp);
146 if (cip->printResponseProc != 0) {
148 (*cip->printResponseProc)(cip, rp);
149 }
151 SaveLastResponse(cip, rp);
152 else
155 }
156} /* ReInitResponse */
Referenced by FTPLoginHost(), and FTPQueryFeatures().
◆ RemoveFileInfo()
| FileInfoPtr RemoveFileInfo | ( | FileInfoListPtr | list, |
| FileInfoPtr | killMe | ||
| ) |
Definition at line 483 of file linelist.c.
484{
485 FileInfoPtr nextFileInfo, prevFileInfo;
486
487 nextFileInfo = killMe->next;
488 prevFileInfo = killMe->prev;
492 }
496 }
500 }
504 }
508 }
509
511 list->first = nextFileInfo;
513 list->last = prevFileInfo;
514
516 nextFileInfo->prev = prevFileInfo;
518 prevFileInfo->next = nextFileInfo;
519
520 free(killMe);
521 list->nFileInfos--;
522 return (nextFileInfo);
523} /* RemoveFileInfo */
◆ RemoveLine()
| LinePtr RemoveLine | ( | LineListPtr | list, |
| LinePtr | killMe | ||
| ) |
Definition at line 63 of file linelist.c.
64{
65 LinePtr nextLine, prevLine;
66
67 nextLine = killMe->next;
68 prevLine = killMe->prev;
72 }
73
75 list->first = nextLine;
77 list->last = prevLine;
78
80 nextLine->prev = prevLine;
82 prevLine->next = nextLine;
83
84 free(killMe);
85 list->nLines--;
86 return (nextLine);
87} /* RemoveLine */
Referenced by FTPRemoteGlob(), and RemoteGlobCollapse().
◆ Scramble()
Definition at line 607 of file util.c.
608{
610 unsigned int ch;
611 unsigned char *k2;
612 size_t keyLen;
613
618 if (ch == 0)
619 break;
621 }
623} /* Scramble */
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
◆ SortFileInfoList()
| void SortFileInfoList | ( | FileInfoListPtr | list, |
| int | sortKey, | ||
| int | sortOrder | ||
| ) |
Definition at line 353 of file linelist.c.
354{
355 FileInfoVec fiv;
356 FileInfoPtr fip;
358
359 fiv = list->vec;
361 return;
362
365 return; /* Already sorted they you want. */
366
367 /* Reverse the sort. */
373 fip = fiv[i];
375 fiv[j] = fip;
376 }
377 }
378
379 list->sortOrder = sortOrder;
380 } else if ((sortKey == 'n') && (sortOrder == 'a')) {
382 NameCmp);
383 list->sortKey = sortKey;
384 list->sortOrder = sortOrder;
385 } else if ((sortKey == 'n') && (sortOrder == 'd')) {
387 ReverseNameCmp);
388 list->sortKey = sortKey;
389 list->sortOrder = sortOrder;
390 } else if ((sortKey == 't') && (sortOrder == 'a')) {
392 TimeCmp);
393 list->sortKey = sortKey;
394 list->sortOrder = sortOrder;
395 } else if ((sortKey == 't') && (sortOrder == 'd')) {
397 ReverseTimeCmp);
398 list->sortKey = sortKey;
399 list->sortOrder = sortOrder;
400 } else if ((sortKey == 's') && (sortOrder == 'a')) {
402 SizeCmp);
403 list->sortKey = sortKey;
404 list->sortOrder = sortOrder;
405 } else if ((sortKey == 's') && (sortOrder == 'd')) {
407 ReverseSizeCmp);
408 list->sortKey = sortKey;
409 list->sortOrder = sortOrder;
410 } else if (sortKey == 'b') {
411 /* This is different from the rest. */
412 list->sortKey = sortKey;
413 list->sortOrder = sortOrder;
415 BreadthFirstCmp);
416 }
417} /* SortFileInfoList */
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
void __cdecl qsort(_Inout_updates_bytes_(_NumOfElements *_SizeOfElements) void *_Base, _In_ size_t _NumOfElements, _In_ size_t _SizeOfElements, _In_ int(__cdecl *_PtFuncCompare)(const void *, const void *))
Referenced by GetLsCacheFileList(), and Ls().
◆ StrDup()
◆ StrRemoveTrailingSlashes()
Definition at line 768 of file util.c.
769{
771
774 return;
775
776 /* Note: Do not destroy a path of "/" */
779} /* StrRemoveTrailingSlashes */
Referenced by FTPGetFiles3(), GetCmd(), PutCmd(), SpoolGetCmd(), and SpoolPutCmd().
◆ TraceResponse()
| void TraceResponse | ( | const | FTPCIPtr, |
| ResponsePtr | rp | ||
| ) |
Definition at line 55 of file rcmd.c.
Referenced by DoneWithResponse(), and ReInitResponse().
◆ UnLslR()
| int UnLslR | ( | FileInfoListPtr | filp, |
| LineListPtr | llp, | ||
| int | serverType | ||
| ) |
Definition at line 561 of file glob.c.
562{
563 char curdir[256];
565 int hadblankline = 0;
567 size_t curdirlen = 0;
568 char fname[256];
569 char linkto[256];
572 int ftype;
574 int thisyear;
576 int rc;
577 LinePtr lp;
578 FileInfo fi;
579 int linesread = 0;
580 int linesconverted = 0;
581 size_t maxFileLen = 0;
582 size_t maxPlugLen = 0;
583 size_t fileLen;
584 int plugend;
585
589 thisyear = 1970; /* should never happen */
590 else
591 thisyear = nowtm->tm_year + 1900;
592
593 curdir[0] = '\0';
594
595 InitFileInfoList(filp);
599 /* total XX line? */
601 hadblankline = 0;
602 continue;
603 }
604 /* else it was a subdir named total */
605 } else {
608 break;
609 }
611 /* Entire line was blank. */
612 /* separator line between dirs */
613 hadblankline = 1;
614 continue;
615 }
616 }
617
619 /* newdir */
620 hadblankline = 0;
629 } else {
633 }
634 continue;
635 }
636
637 linesread++;
638 rc = UnLslRLine(line, curdir, curdirlen, fname, sizeof(fname), linkto, sizeof(linkto), &ftype, &fsize, &ftime, now, thisyear, &plugend);
641 if (rc == 0) {
642 *linkto = '\0';
643 plugend = 0;
644 }
645 }
646 if (rc == 0) {
647 linesconverted++;
648 fileLen = strlen(fname);
649 if (fileLen > maxFileLen)
650 maxFileLen = fileLen;
651 fi.relnameLen = fileLen;
658 fi.type = ftype;
659 if (plugend > 0) {
664 if ((size_t) plugend > maxPlugLen)
665 maxPlugLen = (size_t) plugend;
666 }
667 } else {
672 if (30 > maxPlugLen)
673 maxPlugLen = (size_t) 30;
674 }
675 }
677 }
678
679 hadblankline = 0;
680 }
681
682 filp->maxFileLen = maxFileLen;
683 filp->maxPlugLen = maxPlugLen;
684 if (linesread == 0)
685 return (0);
686 return ((linesconverted > 0) ? linesconverted : (-1));
687} /* UnLslR */
static int UnLslRLine(char *const line, const char *const curdir, size_t curdirlen, char *fname, size_t fnamesize, char *linkto, size_t linktosize, int *ftype, longest_int *fsize, time_t *ftime, time_t now, int thisyear, int *plugend)
Definition: glob.c:353
static int UnDosLine(char *const line, const char *const curdir, size_t curdirlen, char *fname, size_t fnamesize, int *ftype, longest_int *fsize, time_t *ftime)
Definition: glob.c:175
Referenced by FTPRemoteRecursiveFileList(), FTPRemoteRecursiveFileList1(), and Ls().
◆ UnMDTMDate()
Definition at line 486 of file util.c.
487{
488#ifndef HAVE_MKTIME
490#else
494
496 /* Server Y2K bug! */
498 }
499
502
503 /* Copy the whole structure of the 'tm' pointed to by t, so it will
504 * also set all fields we don't specify explicitly to be the same as
505 * they were in t. That way we copy non-standard fields such as
506 * tm_gmtoff, if it exists or not.
507 */
508 ut = *t;
509
510 /* The time we get back from the server is (should be) in UTC. */
512 &ut.tm_year,
513 &ut.tm_mon,
514 &ut.tm_mday,
515 &ut.tm_hour,
516 &ut.tm_min,
517 &ut.tm_sec) == 6)
518 {
519 --ut.tm_mon;
520 ut.tm_year -= 1900;
521 mt = mktime(&ut);
523 mt += GetUTCOffset(ut.tm_mon, ut.tm_mday);
525 }
526 }
528#endif /* HAVE_MKTIME */
529} /* UnMDTMDate */
Referenced by FTPFileModificationTime(), and UnMlsT().
◆ UnMlsD()
| int UnMlsD | ( | FileInfoListPtr | filp, |
| LineListPtr | llp | ||
| ) |
Definition at line 827 of file glob.c.
828{
829 MLstItem mli;
830 char plug[64];
831 char og[32];
832 int rc;
833 LinePtr lp;
834 FileInfo fi;
835 int linesread = 0;
836 int linesconverted = 0;
837 int linesignored = 0;
838 size_t maxFileLen = 0;
839 size_t maxPlugLen = 0;
840 size_t fileLen, plugLen;
841 int m1, m2, m3;
842 const char *cm1, *cm2, *cm3;
843
844 InitFileInfoList(filp);
846 linesread++;
848 if (rc == 0) {
849 linesconverted++;
851 if (fileLen > maxFileLen)
852 maxFileLen = fileLen;
853 fi.relnameLen = fileLen;
862 plug[1] = '\0';
863 m1 = 0;
864 m2 = 0;
865 m3 = -1;
867 m1 = (mli.mode & 00700) >> 6;
868 m2 = (mli.mode & 00070) >> 3;
869 m3 = (mli.mode & 00007);
870 }
872 m3 = 0;
875 /* execute -> execute */
876 m3 |= 00001;
877 }
879 /* create -> write */
880 m3 |= 00002;
881 }
883 /* list -> read */
884 m3 |= 00004;
885 }
886 } else {
888 /* write -> write */
889 m3 |= 00002;
890 }
892 /* read -> read */
893 m3 |= 00004;
894 }
895 }
896 }
897 if (m3 != (-1)) {
898 cm1 = rwx[m1];
899 cm2 = rwx[m2];
900 cm3 = rwx[m3];
902 }
905#ifdef HAVE_SNPRINTF
907#else
908 sprintf(og,
909#endif /* HAVE_SNPRINTF */
910 " %-8.8s %s",
912 );
913 STRNCAT(plug, og);
914 } else {
917 }
918 }
921 plugLen = strlen(plug);
922 if (plugLen > maxPlugLen)
923 maxPlugLen = plugLen;
924 }
926 } else if (rc == (-2)) {
927 linesignored++;
928 }
929 }
930
931 filp->maxFileLen = maxFileLen;
932 filp->maxPlugLen = maxPlugLen;
933 if (linesread == 0)
934 return (0);
935 linesconverted += linesignored;
936 return ((linesconverted > 0) ? linesconverted : (-1));
937} /* UnMlsD */
Referenced by Ls().
◆ UnMlsT()
Definition at line 693 of file glob.c.
694{
696 int ec;
699
701 mlip->mode = -1;
702 mlip->fsize = kSizeUnknown;
703 mlip->ftype = '-';
704 mlip->ftime = kModTimeUnknown;
705
708 return (-1); /* Line too long, sorry. */
709 /* This should be re-coded so does not need to make a
710 * copy of the buffer; it could be done in place.
711 */
713
714 /* Skip leading whitespace. */
717 break;
718 }
719
723 /* protocol violation */
724 return (-1);
725 }
727 /* End of fact name. */
729 break;
730 }
731 }
734 /* protocol violation */
735 return (-1);
736 }
738 ec = ' ';
740 break;
743 ec = ' ';
746 } else {
747 ec = ';';
749 }
750 break;
751 }
752 }
754 fact += 3;
757 mlip->ftype = '-';
759 mlip->ftype = 'd';
761 /* not supported: current directory */
762 return (-2);
764 /* not supported: parent directory */
765 return (-2);
766 } else {
767 /* ? */
768 return (-1);
769 }
773 else
775 if (mlip->mode != (-1))
776 mlip->mode &= 00777;
780#if defined(HAVE_LONG_LONG) && defined(SCANF_LONG_LONG)
782#elif defined(HAVE_LONG_LONG) && defined(HAVE_STRTOQ)
784#else
785 {
787
789 mlip->fsize = (longest_int) fsize2;
790 }
791#endif
804 }
805
806 /* End of facts? */
807 if (ec == ' ')
808 break;
809 }
810
813 /* Filename too long */
814 return (-1);
815 }
817
818 /* also set linkto here if used */
819
820 return (0);
821} /* UnMlsT */
Referenced by FTPMListOneFile(), and UnMlsD().
◆ UnvectorizeFileInfoList()
| void UnvectorizeFileInfoList | ( | FileInfoListPtr | list | ) |
Definition at line 441 of file linelist.c.
442{
443 FileInfoVec fiv;
444 FileInfoPtr fip;
446
447 fiv = list->vec;
449 list->first = fiv[0];
453 fip = fiv[0];
455 fip->next = fiv[1];
457 fip = fiv[i];
460 }
461 }
462 free(fiv);
464 }
465} /* UnvectorizeFileInfoList */
◆ URLCopyToken()
Definition at line 598 of file open.c.
599{
600 char *dlim;
601 const char *slim;
602 unsigned int hc;
605
607 slim = src + howmuch;
611 break;
613 /* hex representation */
618 hc = 0xeeff;
622 dst++;
623 }
624 }
625 } else {
626 break;
627 }
628 } else {
630 }
631 }
633} /* URLCopyToken */
Referenced by FTPDecodeURL().
◆ VectorizeFileInfoList()
| void VectorizeFileInfoList | ( | FileInfoListPtr | list | ) |
Definition at line 423 of file linelist.c.
424{
425 FileInfoVec fiv;
426 FileInfoPtr fip;
428
432 fiv[i] = fip;
433 list->vec = fiv;
434 }
435} /* VectorizeFileInfoList */
Referenced by Ls().
◆ WaitResponse()
Definition at line 684 of file rcmd.c.
685{
690
691#ifdef NO_SIGNALS
692 fd = cip->ctrlSocketR;
693#else /* NO_SIGNALS */
695 return (-1);
697#endif /* NO_SIGNALS */
699 return (-1);
703 tv.tv_usec = 0;
706} /* WaitResponse */
INT WSAAPI select(IN INT s, IN OUT LPFD_SET readfds, IN OUT LPFD_SET writefds, IN OUT LPFD_SET exceptfds, IN CONST struct timeval *timeout)
Definition: select.c:41
Definition: winsock.h:66
Referenced by FTPAbortDataTransfer().
Variable Documentation
◆ gLibNcFTP_Uses_Me_To_Quiet_Variable_Unused_Warnings
|
extern |
◆ gLibNcFTPVersion
|
extern |
Definition at line 11 of file ftp.c.
Referenced by OpenControlConnection(), OpenTrace(), Usage(), and VersionCmd().
