#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

Macros
#define	kLibraryVersion "@(#) LibNcFTP 3.0.6 (April 14, 2001)"

#define	USE_SIO 1

#define	NO_SIGNALS 1

#define	kLibraryMagic "LibNcFTP 3.0.6"

#define	longest_int long long

#define	longest_uint unsigned long long

#define	forever for ( ; ; )

#define	_SReadlineInfo_ 1

#define	kPrInitMsg 1

#define	kPrUpdateMsg 2

#define	kPrEndMsg 3

#define	kSendPortMode 0

#define	kPassiveMode 1

#define	kFallBackToSendPortMode 2

#define	kAcceptForWriting 00100

#define	kAcceptForReading 00101

#define	kNetWriting kAcceptForWriting

#define	kNetReading kAcceptForReading

#define	kResponseNoPrint 00001

#define	kResponseNoSave 00002

#define	kResponseNoProc 00002

#define	kDefaultFTPPort 21

#define	kDefaultFTPBufSize 32768

#define	kDefaultXferTimeout 600

#define	kDefaultConnTimeout 30

#define	kDefaultCtrlTimeout 135

#define	kDefaultAbortTimeout 10

#define	kSuggestedDefaultXferTimeout (0) /* No timeout on data blocks. */

#define	kSuggestedDefaultConnTimeout 30

#define	kSuggestedDefaultCtrlTimeout 135 /* 2MSL, + slop /

#define	kSuggestedAbortTimeout 10

#define	kDefaultMaxDials 3

#define	kDefaultRedialDelay 20 /* seconds */

#define	kDefaultDataPortMode kSendPortMode

#define	kRedialStatusDialing 0

#define	kRedialStatusSleeping 1

#define	INADDR_NONE (0xffffffff) /* <netinet/in.h> should have it. */

#define	kTypeAscii 'A'

#define	kTypeBinary 'I'

#define	kTypeEbcdic 'E'

#define	kGlobChars "[*?"

#define	GLOBCHARSINSTR(a) (strpbrk(a, kGlobChars) != NULL)

#define	kGlobYes 1

#define	kGlobNo 0

#define	kRecursiveYes 1

#define	kRecursiveNo 0

#define	kAppendYes 1

#define	kAppendNo 0

#define	kResumeYes 1

#define	kResumeNo 0

#define	kDeleteYes 1

#define	kDeleteNo 0

#define	kTarYes 1

#define	kTarNo 0

#define	UNIMPLEMENTED_CMD(a) ((a == 500) \|\| (a == 502) \|\| (a == 504))

#define	kSizeUnknown ((longest_int) (-1))

#define	kModTimeUnknown ((time_t) (-1))

#define	kCommandAvailabilityUnknown (-1)

#define	kCommandAvailable 1

#define	kCommandNotAvailable 0

#define	kNotURL (-1)

#define	kMalformedURL (-2)

#define	kFirewallNotInUse 0

#define	kFirewallUserAtSite 1

#define	kFirewallLoginThenUserAtSite 2

#define	kFirewallSiteSite 3

#define	kFirewallOpenSite 4

#define	kFirewallUserAtUserPassAtPass 5

#define	kFirewallFwuAtSiteFwpUserPass 6

#define	kFirewallUserAtSiteFwuPassFwp 7

#define	kFirewallLastType kFirewallUserAtSiteFwuPassFwp

#define	kPreferredMlsOpts (kMlsOptType \| kMlsOptSize \| kMlsOptModify \| kMlsOptUNIXmode \| kMlsOptUNIXowner \| kMlsOptUNIXgroup \| kMlsOptUNIXuid \| kMlsOptUNIXgid \| kMlsOptPerm)

#define	kMlsOptType 00001

#define	kMlsOptSize 00002

#define	kMlsOptModify 00004

#define	kMlsOptUNIXmode 00010

#define	kMlsOptUNIXowner 00020

#define	kMlsOptUNIXgroup 00040

#define	kMlsOptPerm 00100

#define	kMlsOptUNIXuid 00200

#define	kMlsOptUNIXgid 00400

#define	kMlsOptUnique 01000

#define	kFtwFile 0

#define	kFtwDir 1

#define	kChdirOnly 00000

#define	kChdirAndMkdir 00001

#define	kChdirAndGetCWD 00002

#define	kChdirOneSubdirAtATime 00004

#define	kConfirmResumeProcNotUsed 0

#define	kConfirmResumeProcSaidSkip 1

#define	kConfirmResumeProcSaidResume 2

#define	kConfirmResumeProcSaidOverwrite 3

#define	kConfirmResumeProcSaidAppend 4

#define	kConfirmResumeProcSaidBestGuess 5

#define	kConfirmResumeProcSaidCancel 6

#define	NoConfirmResumeDownloadProc ((ConfirmResumeDownloadProc) 0)

#define	NoConfirmResumeUploadProc ((ConfirmResumeUploadProc) 0)

#define	NoGetPassphraseProc ((FTPGetPassphraseProc) 0)

#define	kServerTypeUnknown 0

#define	kServerTypeWuFTPd 1

#define	kServerTypeNcFTPd 2

#define	kServerTypeProFTPD 3

#define	kServerTypeMicrosoftFTP 4

#define	kServerTypeWarFTPd 5

#define	kServerTypeServ_U 6

#define	kServerTypeWFTPD 7

#define	kServerTypeVFTPD 8

#define	kServerTypeFTP_Max 9

#define	kServerTypeRoxen 10

#define	kServerTypeNetWareFTP 11

#define	kServerTypeWS_FTP 12

#define	closesocket close

#define	ioctlsocket ioctl

#define	LOCAL_PATH_DELIM '/'

#define	LOCAL_PATH_DELIM_STR "/"

#define	StrFindLocalPathDelim(a) strchr(a, LOCAL_PATH_DELIM)

#define	StrRFindLocalPathDelim(a) strrchr(a, LOCAL_PATH_DELIM)

#define	StrRemoveTrailingLocalPathDelim StrRemoveTrailingSlashes

#define	IsLocalPathDelim(c) (c == LOCAL_PATH_DELIM)

#define	TVFSPathToLocalPath(s)

#define	LocalPathToTVFSPath(s)

#define	LIBNCFTP_USE_VAR(a) gLibNcFTP_Uses_Me_To_Quiet_Variable_Unused_Warnings = (a == 0)

#define	UNUSED(a) a

#define	NcSignal signal

Typedefs
typedef void(*	FTPSigProc) (int)

typedef struct Line *	LinePtr

typedef struct Line	Line

typedef struct LineList	LineList

typedef struct LineList *	LineListPtr

typedef struct Response	Response

typedef struct Response *	ResponsePtr

typedef struct SReadlineInfo	SReadlineInfo

typedef struct FTPLibraryInfo	FTPLibraryInfo

typedef struct FTPLibraryInfo *	FTPLIPtr

typedef struct FTPConnectionInfo *	FTPCIPtr

typedef void(*	FTPProgressMeterProc) (const FTPCIPtr, int)

typedef void(*	FTPLogProc) (const FTPCIPtr, char *)

typedef void(*	FTPConnectMessageProc) (const FTPCIPtr, ResponsePtr)

typedef void(*	FTPLoginMessageProc) (const FTPCIPtr, ResponsePtr)

typedef void(*	FTPRedialStatusProc) (const FTPCIPtr, int, int)

typedef void(*	FTPPrintResponseProc) (const FTPCIPtr, ResponsePtr)

typedef int(*	FTPFtwProc) (const FTPCIPtr cip, const char *fn, int flag)

typedef void(*	FTPGetPassphraseProc) (const FTPCIPtr, LineListPtr pwPrompt, char *pass, size_t dsize)

typedef struct FTPConnectionInfo	FTPConnectionInfo

typedef struct FileInfo *	FileInfoPtr

typedef struct FileInfo **	FileInfoVec

typedef struct FileInfo	FileInfo

typedef struct FileInfoList	FileInfoList

typedef struct FileInfoList *	FileInfoListPtr

typedef struct MLstItem	MLstItem

typedef struct MLstItem *	MLstItemPtr

typedef 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)

typedef int(*	ConfirmResumeUploadProc) (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)

Functions
void	FTPAbortDataTransfer (const FTPCIPtr cip)

int	FTPChdir (const FTPCIPtr cip, const char *const cdCwd)

int	FTPChdirAndGetCWD (const FTPCIPtr cip, const char const cdCwd, char const newCwd, const size_t newCwdSize)

int	FTPChdir3 (FTPCIPtr cip, const char const cdCwd, char const newCwd, const size_t newCwdSize, int flags)

int	FTPChmod (const FTPCIPtr cip, const char const pattern, const char const mode, const int doGlob)

int	FTPCloseHost (const FTPCIPtr cip)

int	FTPCmd (const FTPCIPtr cip, const char *const cmdspec,...)

int	FTPDecodeURL (const FTPCIPtr cip, char const url, LineListPtr cdlist, char const fn, const size_t fnsize, int const xtype, int const wantnlst)

int	FTPDelete (const FTPCIPtr cip, const char *const pattern, const int recurse, const int doGlob)

int	FTPFileExists (const FTPCIPtr cip, const char *const file)

int	FTPFileModificationTime (const FTPCIPtr cip, const char const file, time_t const mdtm)

int	FTPFileSize (const FTPCIPtr cip, const char const file, longest_int const size, const int type)

int	FTPFileSizeAndModificationTime (const FTPCIPtr cip, const char const file, longest_int const size, const int type, time_t *const mdtm)

int	FTPFileType (const FTPCIPtr cip, const char const file, int const ftype)

int	FTPGetCWD (const FTPCIPtr cip, char *const newCwd, const size_t newCwdSize)

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)

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)

int	FTPInitConnectionInfo (const FTPLIPtr lip, const FTPCIPtr cip, size_t bufsize)

int	FTPInitLibrary (const FTPLIPtr lip)

int	FTPIsDir (const FTPCIPtr cip, const char *const dir)

int	FTPIsRegularFile (const FTPCIPtr cip, const char *const file)

int	FTPList (const FTPCIPtr cip, const int outfd, const int longMode, const char *const lsflag)

int	FTPListToMemory (const FTPCIPtr cip, const char const pattern, const LineListPtr llines, const char const lsflags)

int	FTPLocalGlob (FTPCIPtr cip, LineListPtr fileList, const char *pattern, int doGlob)

int	FTPLoginHost (const FTPCIPtr cip)

int	FTPMkdir (const FTPCIPtr cip, const char *const newDir, const int recurse)

int	FTPMkdir2 (const FTPCIPtr cip, const char const newDir, const int recurse, const char const curDir)

int	FTPOpenHost (const FTPCIPtr cip)

int	FTPOpenHostNoLogin (const FTPCIPtr cip)

void	FTPPerror (const FTPCIPtr cip, const int err, const int eerr, const char const s1, const char const s2)

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)

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)

int	FTPRemoteGlob (FTPCIPtr cip, LineListPtr fileList, const char *pattern, int doGlob)

int	FTPRename (const FTPCIPtr cip, const char const oldname, const char const newname)

int	FTPRmdir (const FTPCIPtr cip, const char *const pattern, const int recurse, const int doGlob)

void	FTPShutdownHost (const FTPCIPtr cip)

const char *	FTPStrError (int e)

int	FTPSymlink (const FTPCIPtr cip, const char const lfrom, const char const lto)

int	FTPUmask (const FTPCIPtr cip, const char *const umsk)

int	FTPUtime (const FTPCIPtr cip, const char *const file, time_t actime, time_t modtime, time_t crtime)

int	CopyLineList (LineListPtr, LineListPtr)

void	DisposeLineListContents (LineListPtr)

void	InitLineList (LineListPtr)

LinePtr	RemoveLine (LineListPtr, LinePtr)

LinePtr	AddLine (LineListPtr, const char *)

char *	StrDup (const char *)

char *	FGets (char , size_t, FILE )

void	GetHomeDir (char *, size_t)

void	GetUsrName (char *, size_t)

void	Scramble (unsigned char dst, size_t dsize, unsigned char src, char *key)

time_t	UnMDTMDate (char *)

int	MkDirs (const char *const, int mode1)

char *	GetPass (const char *const prompt)

int	FilenameExtensionIndicatesASCII (const char const pathName, const char const extnList)

void	StrRemoveTrailingSlashes (char *dst)

int	FTPGetOneFile (const FTPCIPtr cip, const char const file, const char const dstfile)

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)

int	FTPGetFiles (const FTPCIPtr cip, const char const pattern, const char const dstdir, const int recurse, const int doGlob)

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)

int	FTPGetOneFileAscii (const FTPCIPtr cip, const char const file, const char const dstfile)

int	FTPGetFilesAscii (const FTPCIPtr cip, const char const pattern, const char const dstdir, const int recurse, const int doGlob)

int	FTPPutOneFile (const FTPCIPtr cip, const char const file, const char const dstfile)

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)

int	FTPPutFiles (const FTPCIPtr cip, const char const pattern, const char const dstdir, const int recurse, const int doGlob)

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)

int	FTPPutOneFileAscii (const FTPCIPtr cip, const char const file, const char const dstfile)

int	FTPPutFilesAscii (const FTPCIPtr cip, const char const pattern, const char const dstdir, const int recurse, const int doGlob)

char *	FTPGetLocalCWD (char *buf, size_t size)

int	FTPQueryFeatures (const FTPCIPtr)

int	FTPMListOneFile (const FTPCIPtr cip, const char *const file, const MLstItemPtr mlip)

void	FTPInitializeOurHostName (const FTPLIPtr)

void	FTPInitializeAnonPassword (const FTPLIPtr)

int	FTPListToMemory2 (const FTPCIPtr cip, const char const pattern, const LineListPtr llines, const char const lsflags, const int blanklines, int *const tryMLSD)

void	FTPInitIOTimer (const FTPCIPtr)

int	FTPStartDataCmd (const FTPCIPtr, int, int, longest_int, const char *,...)

void	FTPStartIOTimer (const FTPCIPtr)

void	FTPStopIOTimer (const FTPCIPtr)

void	FTPUpdateIOTimer (const FTPCIPtr)

int	FTPSetTransferType (const FTPCIPtr, int)

int	FTPEndDataCmd (const FTPCIPtr, int)

int	FTPRemoteHelp (const FTPCIPtr, const char *const, const LineListPtr)

int	FTPCmdNoResponse (const FTPCIPtr, const char *const cmdspec,...)

int	WaitResponse (const FTPCIPtr, unsigned int)

int	FTPLocalRecursiveFileList (FTPCIPtr, LineListPtr, FileInfoListPtr)

int	FTPLocalRecursiveFileList2 (FTPCIPtr cip, LineListPtr fileList, FileInfoListPtr files, int erelative)

int	FTPRemoteRecursiveFileList (FTPCIPtr, LineListPtr, FileInfoListPtr)

int	FTPRemoteRecursiveFileList1 (FTPCIPtr, char *const, FileInfoListPtr)

int	FTPRebuildConnectionInfo (const FTPLIPtr lip, const FTPCIPtr cip)

int	FTPFileExistsStat (const FTPCIPtr cip, const char *const file)

int	FTPFileExistsNlst (const FTPCIPtr cip, const char *const file)

int	FTPFileExists2 (const FTPCIPtr cip, const char *const file, const int tryMDTM, const int trySIZE, const int tryMLST, const int trySTAT, const int tryNLST)

int	FTPFtw (const FTPCIPtr cip, const char *const dir, FTPFtwProc proc, int maxdepth)

int	BufferGets (char , size_t, int, char , char , char , size_t)

void	DisposeFileInfoListContents (FileInfoListPtr)

void	InitFileInfoList (FileInfoListPtr)

void	InitFileInfo (FileInfoPtr)

FileInfoPtr	RemoveFileInfo (FileInfoListPtr, FileInfoPtr)

FileInfoPtr	AddFileInfo (FileInfoListPtr, FileInfoPtr)

void	SortFileInfoList (FileInfoListPtr, int, int)

void	VectorizeFileInfoList (FileInfoListPtr)

void	UnvectorizeFileInfoList (FileInfoListPtr)

int	ComputeRNames (FileInfoListPtr, const char *, int, int)

int	ComputeLNames (FileInfoListPtr, const char , const char , int)

int	ConcatFileInfoList (FileInfoListPtr, FileInfoListPtr)

int	ConcatFileToFileInfoList (FileInfoListPtr, char *)

int	LineListToFileInfoList (LineListPtr, FileInfoListPtr)

int	LineToFileInfoList (LinePtr, FileInfoListPtr)

void	URLCopyToken (char , size_t, const char , size_t)

int	UnMlsT (const char *const, const MLstItemPtr)

int	UnMlsD (FileInfoListPtr, LineListPtr)

int	UnLslR (FileInfoListPtr, LineListPtr, int)

void	TraceResponse (const FTPCIPtr, ResponsePtr)

void	PrintResponse (const FTPCIPtr, LineListPtr)

void	DoneWithResponse (const FTPCIPtr, ResponsePtr)

ResponsePtr	InitResponse (void)

void	ReInitResponse (const FTPCIPtr, ResponsePtr)

int	GetTelnetString (const FTPCIPtr, char , size_t, FILE , FILE *)

int	GetResponse (const FTPCIPtr, ResponsePtr)

int	RCmd (const FTPCIPtr, ResponsePtr, const char *,...)

Variables
char	gLibNcFTPVersion [64]

int	gLibNcFTP_Uses_Me_To_Quiet_Variable_Unused_Warnings

Macro Definition Documentation

◆ _SReadlineInfo_

#define _SReadlineInfo_ 1

Definition at line 99 of file ncftp.h.

◆ closesocket

#define closesocket close

Definition at line 477 of file ncftp.h.

◆ forever

#define forever for ( ; ; )

Definition at line 73 of file ncftp.h.

◆ GLOBCHARSINSTR

#define GLOBCHARSINSTR ( a ) (strpbrk(a, kGlobChars) != NULL)

Definition at line 358 of file ncftp.h.

◆ INADDR_NONE

#define INADDR_NONE (0xffffffff) /* <netinet/in.h> should have it. */

Definition at line 350 of file ncftp.h.

◆ ioctlsocket

#define ioctlsocket ioctl

Definition at line 481 of file ncftp.h.

◆ IsLocalPathDelim

#define IsLocalPathDelim ( c ) (c == LOCAL_PATH_DELIM)

Definition at line 497 of file ncftp.h.

◆ kAcceptForReading

#define kAcceptForReading 00101

Definition at line 301 of file ncftp.h.

◆ kAcceptForWriting

#define kAcceptForWriting 00100

Definition at line 300 of file ncftp.h.

◆ kAppendNo

#define kAppendNo 0

Definition at line 365 of file ncftp.h.

◆ kAppendYes

#define kAppendYes 1

Definition at line 364 of file ncftp.h.

◆ kChdirAndGetCWD

#define kChdirAndGetCWD 00002

Definition at line 419 of file ncftp.h.

◆ kChdirAndMkdir

#define kChdirAndMkdir 00001

Definition at line 418 of file ncftp.h.

◆ kChdirOneSubdirAtATime

#define kChdirOneSubdirAtATime 00004

Definition at line 420 of file ncftp.h.

◆ kChdirOnly

#define kChdirOnly 00000

Definition at line 417 of file ncftp.h.

◆ kCommandAvailabilityUnknown

#define kCommandAvailabilityUnknown (-1)

Definition at line 379 of file ncftp.h.

◆ kCommandAvailable

#define kCommandAvailable 1

Definition at line 380 of file ncftp.h.

◆ kCommandNotAvailable

#define kCommandNotAvailable 0

Definition at line 381 of file ncftp.h.

◆ kConfirmResumeProcNotUsed

#define kConfirmResumeProcNotUsed 0

Definition at line 423 of file ncftp.h.

◆ kConfirmResumeProcSaidAppend

#define kConfirmResumeProcSaidAppend 4

Definition at line 427 of file ncftp.h.

◆ kConfirmResumeProcSaidBestGuess

#define kConfirmResumeProcSaidBestGuess 5

Definition at line 428 of file ncftp.h.

◆ kConfirmResumeProcSaidCancel

#define kConfirmResumeProcSaidCancel 6

Definition at line 429 of file ncftp.h.

◆ kConfirmResumeProcSaidOverwrite

#define kConfirmResumeProcSaidOverwrite 3

Definition at line 426 of file ncftp.h.

◆ kConfirmResumeProcSaidResume

#define kConfirmResumeProcSaidResume 2

Definition at line 425 of file ncftp.h.

◆ kConfirmResumeProcSaidSkip

#define kConfirmResumeProcSaidSkip 1

Definition at line 424 of file ncftp.h.

◆ kDefaultAbortTimeout

#define kDefaultAbortTimeout 10

Definition at line 323 of file ncftp.h.

◆ kDefaultConnTimeout

#define kDefaultConnTimeout 30

Definition at line 321 of file ncftp.h.

◆ kDefaultCtrlTimeout

#define kDefaultCtrlTimeout 135

Definition at line 322 of file ncftp.h.

◆ kDefaultDataPortMode

#define kDefaultDataPortMode kSendPortMode

Definition at line 344 of file ncftp.h.

◆ kDefaultFTPBufSize

#define kDefaultFTPBufSize 32768

Definition at line 314 of file ncftp.h.

◆ kDefaultFTPPort

#define kDefaultFTPPort 21

Definition at line 312 of file ncftp.h.

◆ kDefaultMaxDials

#define kDefaultMaxDials 3

Definition at line 341 of file ncftp.h.

◆ kDefaultRedialDelay

#define kDefaultRedialDelay 20 /* seconds */

Definition at line 342 of file ncftp.h.

◆ kDefaultXferTimeout

#define kDefaultXferTimeout 600

Definition at line 320 of file ncftp.h.

◆ kDeleteNo

#define kDeleteNo 0

Definition at line 369 of file ncftp.h.

◆ kDeleteYes

#define kDeleteYes 1

Definition at line 368 of file ncftp.h.

◆ kFallBackToSendPortMode

#define kFallBackToSendPortMode 2

Definition at line 297 of file ncftp.h.

◆ kFirewallFwuAtSiteFwpUserPass

#define kFirewallFwuAtSiteFwpUserPass 6

Definition at line 394 of file ncftp.h.

◆ kFirewallLastType

#define kFirewallLastType kFirewallUserAtSiteFwuPassFwp

Definition at line 396 of file ncftp.h.

◆ kFirewallLoginThenUserAtSite

#define kFirewallLoginThenUserAtSite 2

Definition at line 390 of file ncftp.h.

◆ kFirewallNotInUse

#define kFirewallNotInUse 0

Definition at line 388 of file ncftp.h.

◆ kFirewallOpenSite

#define kFirewallOpenSite 4

Definition at line 392 of file ncftp.h.

◆ kFirewallSiteSite

#define kFirewallSiteSite 3

Definition at line 391 of file ncftp.h.

◆ kFirewallUserAtSite

#define kFirewallUserAtSite 1

Definition at line 389 of file ncftp.h.

◆ kFirewallUserAtSiteFwuPassFwp

#define kFirewallUserAtSiteFwuPassFwp 7

Definition at line 395 of file ncftp.h.

◆ kFirewallUserAtUserPassAtPass

#define kFirewallUserAtUserPassAtPass 5

Definition at line 393 of file ncftp.h.

◆ kFtwDir

#define kFtwDir 1

Definition at line 414 of file ncftp.h.

◆ kFtwFile

#define kFtwFile 0

Definition at line 413 of file ncftp.h.

◆ kGlobChars

#define kGlobChars "[*?"

Definition at line 357 of file ncftp.h.

◆ kGlobNo

#define kGlobNo 0

Definition at line 361 of file ncftp.h.

◆ kGlobYes

#define kGlobYes 1

Definition at line 360 of file ncftp.h.

◆ kLibraryMagic

#define kLibraryMagic "LibNcFTP 3.0.6"

Definition at line 65 of file ncftp.h.

◆ kLibraryVersion

#define kLibraryVersion "@(#) LibNcFTP 3.0.6 (April 14, 2001)"

Definition at line 11 of file ncftp.h.

◆ kMalformedURL

#define kMalformedURL (-2)

Definition at line 385 of file ncftp.h.

◆ kMlsOptModify

#define kMlsOptModify 00004

Definition at line 403 of file ncftp.h.

◆ kMlsOptPerm

#define kMlsOptPerm 00100

Definition at line 407 of file ncftp.h.

◆ kMlsOptSize

#define kMlsOptSize 00002

Definition at line 402 of file ncftp.h.

◆ kMlsOptType

#define kMlsOptType 00001

Definition at line 401 of file ncftp.h.

◆ kMlsOptUnique

#define kMlsOptUnique 01000

Definition at line 410 of file ncftp.h.

◆ kMlsOptUNIXgid

#define kMlsOptUNIXgid 00400

Definition at line 409 of file ncftp.h.

◆ kMlsOptUNIXgroup

#define kMlsOptUNIXgroup 00040

Definition at line 406 of file ncftp.h.

◆ kMlsOptUNIXmode

#define kMlsOptUNIXmode 00010

Definition at line 404 of file ncftp.h.

◆ kMlsOptUNIXowner

#define kMlsOptUNIXowner 00020

Definition at line 405 of file ncftp.h.

◆ kMlsOptUNIXuid

#define kMlsOptUNIXuid 00200

Definition at line 408 of file ncftp.h.

◆ kModTimeUnknown

#define kModTimeUnknown ((time_t) (-1))

Definition at line 377 of file ncftp.h.

◆ kNetReading

#define kNetReading kAcceptForReading

Definition at line 303 of file ncftp.h.

◆ kNetWriting

#define kNetWriting kAcceptForWriting

Definition at line 302 of file ncftp.h.

◆ kNotURL

#define kNotURL (-1)

Definition at line 384 of file ncftp.h.

◆ kPassiveMode

#define kPassiveMode 1

Definition at line 296 of file ncftp.h.

◆ kPreferredMlsOpts

Definition at line 399 of file ncftp.h.

◆ kPrEndMsg

#define kPrEndMsg 3

Definition at line 292 of file ncftp.h.

◆ kPrInitMsg

#define kPrInitMsg 1

Definition at line 290 of file ncftp.h.

◆ kPrUpdateMsg

#define kPrUpdateMsg 2

Definition at line 291 of file ncftp.h.

◆ kRecursiveNo

#define kRecursiveNo 0

Definition at line 363 of file ncftp.h.

◆ kRecursiveYes

#define kRecursiveYes 1

Definition at line 362 of file ncftp.h.

◆ kRedialStatusDialing

#define kRedialStatusDialing 0

Definition at line 346 of file ncftp.h.

◆ kRedialStatusSleeping

#define kRedialStatusSleeping 1

Definition at line 347 of file ncftp.h.

◆ kResponseNoPrint

#define kResponseNoPrint 00001

Definition at line 308 of file ncftp.h.

◆ kResponseNoProc

#define kResponseNoProc 00002

Definition at line 310 of file ncftp.h.

◆ kResponseNoSave

#define kResponseNoSave 00002

Definition at line 309 of file ncftp.h.

◆ kResumeNo

#define kResumeNo 0

Definition at line 367 of file ncftp.h.

◆ kResumeYes

#define kResumeYes 1

Definition at line 366 of file ncftp.h.

◆ kSendPortMode

#define kSendPortMode 0

Definition at line 295 of file ncftp.h.

◆ kServerTypeFTP_Max

#define kServerTypeFTP_Max 9

Definition at line 470 of file ncftp.h.

◆ kServerTypeMicrosoftFTP

#define kServerTypeMicrosoftFTP 4

Definition at line 465 of file ncftp.h.

◆ kServerTypeNcFTPd

#define kServerTypeNcFTPd 2

Definition at line 463 of file ncftp.h.

◆ kServerTypeNetWareFTP

#define kServerTypeNetWareFTP 11

Definition at line 472 of file ncftp.h.

◆ kServerTypeProFTPD

#define kServerTypeProFTPD 3

Definition at line 464 of file ncftp.h.

◆ kServerTypeRoxen

#define kServerTypeRoxen 10

Definition at line 471 of file ncftp.h.

◆ kServerTypeServ_U

#define kServerTypeServ_U 6

Definition at line 467 of file ncftp.h.

◆ kServerTypeUnknown

#define kServerTypeUnknown 0

Definition at line 461 of file ncftp.h.

◆ kServerTypeVFTPD

#define kServerTypeVFTPD 8

Definition at line 469 of file ncftp.h.

◆ kServerTypeWarFTPd

#define kServerTypeWarFTPd 5

Definition at line 466 of file ncftp.h.

◆ kServerTypeWFTPD

#define kServerTypeWFTPD 7

Definition at line 468 of file ncftp.h.

◆ kServerTypeWS_FTP

#define kServerTypeWS_FTP 12

Definition at line 473 of file ncftp.h.

◆ kServerTypeWuFTPd

#define kServerTypeWuFTPd 1

Definition at line 462 of file ncftp.h.

◆ kSizeUnknown

#define kSizeUnknown ((longest_int) (-1))

Definition at line 376 of file ncftp.h.

◆ kSuggestedAbortTimeout

#define kSuggestedAbortTimeout 10

Definition at line 339 of file ncftp.h.

◆ kSuggestedDefaultConnTimeout

#define kSuggestedDefaultConnTimeout 30

Definition at line 337 of file ncftp.h.

◆ kSuggestedDefaultCtrlTimeout

#define kSuggestedDefaultCtrlTimeout 135 /* 2*MSL, + slop */

Definition at line 338 of file ncftp.h.

◆ kSuggestedDefaultXferTimeout

#define kSuggestedDefaultXferTimeout (0) /* No timeout on data blocks. */

Definition at line 336 of file ncftp.h.

◆ kTarNo

#define kTarNo 0

Definition at line 371 of file ncftp.h.

◆ kTarYes

#define kTarYes 1

Definition at line 370 of file ncftp.h.

◆ kTypeAscii

#define kTypeAscii 'A'

Definition at line 353 of file ncftp.h.

◆ kTypeBinary

#define kTypeBinary 'I'

Definition at line 354 of file ncftp.h.

◆ kTypeEbcdic

#define kTypeEbcdic 'E'

Definition at line 355 of file ncftp.h.

◆ LIBNCFTP_USE_VAR

#define LIBNCFTP_USE_VAR ( a ) gLibNcFTP_Uses_Me_To_Quiet_Variable_Unused_Warnings = (a == 0)

Definition at line 521 of file ncftp.h.

◆ LOCAL_PATH_DELIM

#define LOCAL_PATH_DELIM '/'

Definition at line 492 of file ncftp.h.

◆ LOCAL_PATH_DELIM_STR

#define LOCAL_PATH_DELIM_STR "/"

Definition at line 493 of file ncftp.h.

◆ LocalPathToTVFSPath

#define LocalPathToTVFSPath ( s )

Definition at line 499 of file ncftp.h.

◆ longest_int

#define longest_int long long

Definition at line 68 of file ncftp.h.

◆ longest_uint

#define longest_uint unsigned long long

Definition at line 69 of file ncftp.h.

◆ NcSignal

#define NcSignal signal

Definition at line 604 of file ncftp.h.

◆ NO_SIGNALS

#define NO_SIGNALS 1

Definition at line 49 of file ncftp.h.

◆ NoConfirmResumeDownloadProc

#define NoConfirmResumeDownloadProc ((ConfirmResumeDownloadProc) 0)

Definition at line 451 of file ncftp.h.

◆ NoConfirmResumeUploadProc

#define NoConfirmResumeUploadProc ((ConfirmResumeUploadProc) 0)

Definition at line 452 of file ncftp.h.

◆ NoGetPassphraseProc

#define NoGetPassphraseProc ((FTPGetPassphraseProc) 0)

Definition at line 453 of file ncftp.h.

◆ StrFindLocalPathDelim

#define StrFindLocalPathDelim ( a ) strchr(a, LOCAL_PATH_DELIM)

Definition at line 494 of file ncftp.h.

◆ StrRemoveTrailingLocalPathDelim

#define StrRemoveTrailingLocalPathDelim StrRemoveTrailingSlashes

Definition at line 496 of file ncftp.h.

◆ StrRFindLocalPathDelim

#define StrRFindLocalPathDelim ( a ) strrchr(a, LOCAL_PATH_DELIM)

Definition at line 495 of file ncftp.h.

◆ TVFSPathToLocalPath

#define TVFSPathToLocalPath ( s )

Definition at line 498 of file ncftp.h.

◆ UNIMPLEMENTED_CMD

#define UNIMPLEMENTED_CMD ( a ) ((a == 500) || (a == 502) || (a == 504))

Definition at line 373 of file ncftp.h.

◆ UNUSED

#define UNUSED ( a ) a

Definition at line 523 of file ncftp.h.

◆ USE_SIO

#define USE_SIO 1

Definition at line 46 of file ncftp.h.

Typedef Documentation

◆ ConfirmResumeDownloadProc

typedef 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 at line 431 of file ncftp.h.

◆ ConfirmResumeUploadProc

typedef int(* ConfirmResumeUploadProc) (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 at line 441 of file ncftp.h.

◆ FileInfo

typedef struct FileInfo FileInfo

◆ FileInfoList

typedef struct FileInfoList FileInfoList

◆ FileInfoListPtr

typedef struct FileInfoList * FileInfoListPtr

◆ FileInfoPtr

typedef struct FileInfo* FileInfoPtr

Definition at line 250 of file ncftp.h.

◆ FileInfoVec

typedef struct FileInfo ** FileInfoVec

Definition at line 250 of file ncftp.h.

◆ FTPCIPtr

typedef struct FTPConnectionInfo* FTPCIPtr

Definition at line 124 of file ncftp.h.

◆ FTPConnectionInfo

typedef struct FTPConnectionInfo FTPConnectionInfo

◆ FTPConnectMessageProc

typedef void(* FTPConnectMessageProc) (const FTPCIPtr, ResponsePtr)

Definition at line 127 of file ncftp.h.

◆ FTPFtwProc

typedef int(* FTPFtwProc) (const FTPCIPtr cip, const char *fn, int flag)

Definition at line 131 of file ncftp.h.

◆ FTPGetPassphraseProc

typedef void(* FTPGetPassphraseProc) (const FTPCIPtr, LineListPtr pwPrompt, char *pass, size_t dsize)

Definition at line 132 of file ncftp.h.

◆ FTPLibraryInfo

typedef struct FTPLibraryInfo FTPLibraryInfo

◆ FTPLIPtr

typedef struct FTPLibraryInfo * FTPLIPtr

◆ FTPLoginMessageProc

typedef void(* FTPLoginMessageProc) (const FTPCIPtr, ResponsePtr)

Definition at line 128 of file ncftp.h.

◆ FTPLogProc

typedef void(* FTPLogProc) (const FTPCIPtr, char *)

Definition at line 126 of file ncftp.h.

◆ FTPPrintResponseProc

typedef void(* FTPPrintResponseProc) (const FTPCIPtr, ResponsePtr)

Definition at line 130 of file ncftp.h.

◆ FTPProgressMeterProc

typedef void(* FTPProgressMeterProc) (const FTPCIPtr, int)

Definition at line 125 of file ncftp.h.

◆ FTPRedialStatusProc

typedef void(* FTPRedialStatusProc) (const FTPCIPtr, int, int)

Definition at line 129 of file ncftp.h.

◆ FTPSigProc

typedef void(* FTPSigProc) (int)

Definition at line 76 of file ncftp.h.

◆ Line

_In_ WDFDEVICE _In_opt_ PVOID _In_ LONG Line

Definition at line 4085 of file wdfdevice.h.

◆ LineList

typedef struct LineList LineList

◆ LineListPtr

typedef struct LineList * LineListPtr

◆ LinePtr

typedef struct Line* LinePtr

Definition at line 78 of file ncftp.h.

◆ MLstItem

typedef struct MLstItem MLstItem

◆ MLstItemPtr

typedef struct MLstItem * MLstItemPtr

◆ Response

typedef struct Response 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.

{
    FileInfoPtr lp;
 
    lp = (FileInfoPtr) malloc(sizeof(FileInfo));
    if (lp != NULL) {
        (void) memcpy(lp, src, sizeof(FileInfo));
        lp->next = NULL;
        if (list->first == NULL) {
            list->first = list->last = lp;
            lp->prev = NULL;
            list->nFileInfos = 1;
        } else {
            lp->prev = list->last;
            list->last->next = lp;
            list->last = lp;
            list->nFileInfos++;
        }
    }
    return lp;
}   /* AddFileInfo */

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.

{
    LinePtr lp;
    char *buf;
 
    lp = (LinePtr) malloc(sizeof(Line));
    if (lp != NULL) {
        buf = StrDup(buf1);
        if (buf == NULL) {
            free(lp);
            lp = NULL;
        } else {
            lp->line = buf;
            lp->next = NULL;
            if (list->first == NULL) {
                list->first = list->last = lp;
                lp->prev = NULL;
                list->nLines = 1;
            } else {
                lp->prev = list->last;
                list->last->next = lp;
                list->last = lp;
                list->nLines++;
            }
        }
    }
    return lp;
}   /* AddLine */

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.

{
    int err;
    char *src;
    char *dst;
    char *dstlim;
    int len;
    int nr;
    int haveEof = 0;
 
    err = 0;
    dst = buf;
    dstlim = dst + bufsize - 1;     /* Leave room for NUL. */
    src = (*secBufPtr);
    for ( ; dst < dstlim; ) {
        if (src >= (*secBufLimit)) {
            /* Fill the buffer. */
 
/* Don't need to poll it here.  The routines that use BufferGets don't
 * need any special processing during timeouts (i.e. progress reports),
 * so go ahead and just let it block until there is data to read.
 */
            nr = (int) read(inStream, secondaryBuf, secBufSize);
            if (nr == 0) {
                /* EOF. */
                haveEof = 1;
                goto done;
            } else if (nr < 0) {
                /* Error. */
                err = -1;
                goto done;
            }
            (*secBufPtr) = secondaryBuf;
            (*secBufLimit) = secondaryBuf + nr;
            src = (*secBufPtr);
            if (nr < (int) secBufSize)
                src[nr] = '\0';
        }
        if (*src == '\r') {
            ++src;
        } else {
            if (*src == '\n') {
                /* *dst++ = *src++; */  ++src;
                goto done;
            }
            *dst++ = *src++;
        }
    }
 
done:
    (*secBufPtr) = src;
    *dst = '\0';
    len = (int) (dst - buf);
    if (err < 0)
        return (err);
    if ((len == 0) && (haveEof == 1))
        return (-1);
    return (len);   /* May be zero, if a blank line. */
}   /* BufferGets */

Referenced by FTPList(), and FTPListToMemory2().

◆ ComputeLNames()

int ComputeLNames	(	FileInfoListPtr	dst,
		const char *	srcdir,
		const char *	dstdir,
		int	nochop
	)

Definition at line 663 of file linelist.c.

{
    FileInfoPtr lp, lp2;
    char *buf;
    char *cp;
 
    if (srcdir != NULL) {
        cp = strrchr(srcdir, '/');
        if (cp == NULL)
            cp = strrchr(srcdir, '\\');
        if (cp != NULL)
            srcdir = cp + 1;
    }
    if (dstdir == NULL)
        dstdir = ".";
 
    for (lp = dst->first; lp != NULL; lp = lp2) {
        lp2 = lp->next;
 
        buf = NULL;
        if (nochop != 0) {
            if ((dstdir[0] != '\0') && (strcmp(dstdir, "."))) {
                if (Dynscat(&buf, dstdir, "/", 0) == NULL)
                    goto memerr;
            }
            if (lp->lname != NULL) {
                if (Dynscat(&buf, lp->lname, "/", 0) == NULL)
                    goto memerr;
            } else if (srcdir != NULL) {
                if (Dynscat(&buf, srcdir, "/", 0) == NULL)
                    goto memerr;
            }
            if (Dynscat(&buf, lp->relname, 0) == NULL)
                goto memerr;
        } else {
            if ((dstdir[0] != '\0') && (strcmp(dstdir, "."))) {
                cp = strrchr(lp->relname, '/');
                if (cp == NULL)
                    cp = strrchr(lp->relname, '\\');
                if (cp == NULL) {
                    cp = lp->relname;
                } else {
                    cp++;
                }
                if (Dynscat(&buf, dstdir, "/", cp, 0) == NULL)
                    goto memerr;
            } else {
                cp = strrchr(lp->relname, '/');
                if (cp == NULL)
                    cp = strrchr(lp->relname, '\\');
                if (cp == NULL) {
                    cp = lp->relname;
                } else {
                    cp++;
                }
                if (Dynscat(&buf, cp, 0) == NULL)
                    goto memerr;
            }
        }
        if (buf == NULL) {
memerr:
            return (-1);
        }
        if (lp->lname != NULL) {
            free(lp->lname);
            lp->lname = NULL;
        }
        lp->lname = buf;
        TVFSPathToLocalPath(lp->lname);
    }
    return (0);
}   /* ComputeLNames */

Referenced by FTPGetFiles3(), and FTPPutFiles3().

◆ ComputeRNames()

int ComputeRNames	(	FileInfoListPtr	dst,
		const char *	dstdir,
		int	pflag,
		int	nochop
	)

Definition at line 579 of file linelist.c.

{
    FileInfoPtr lp, lp2;
    char *buf;
    char *cp;
 
    if (dstdir == NULL)
        dstdir = ".";
 
    for (lp = dst->first; lp != NULL; lp = lp2) {
        lp2 = lp->next;
 
        buf = NULL;
        if (nochop != 0) {
            if ((dstdir[0] != '\0') && (strcmp(dstdir, "."))) {
                if (Dynscat(&buf, dstdir, "/", lp->relname, 0) == NULL)
                    goto memerr;
 
                if (pflag != 0) {
                    /* Init lname to parent dir name of remote dir */
                    cp = strrchr(dstdir, '/');
                    if (cp == NULL)
                        cp = strrchr(dstdir, '\\');
                    if (cp != NULL) {
                        if (Dynscat(&lp->lname, cp + 1, 0) == NULL)
                            goto memerr;
                        TVFSPathToLocalPath(lp->lname);
                    }
                }
            } else {
                if (Dynscat(&buf, lp->relname, 0) == NULL)
                    goto memerr;
            }
        } else {
            if ((dstdir[0] != '\0') && (strcmp(dstdir, "."))) {
                cp = strrchr(lp->relname, '/');
                if (cp == NULL)
                    cp = strrchr(lp->relname, '\\');
                if (cp != NULL) {
                    cp++;
                } else {
                    cp = lp->relname;
                }
                if (Dynscat(&buf, dstdir, "/", cp, 0) == NULL)
                    goto memerr;
 
                if (pflag != 0) {
                    /* Init lname to parent dir name of remote dir */
                    cp = strrchr(dstdir, '/');
                    if (cp == NULL)
                        cp = strrchr(dstdir, '\\');
                    if (cp != NULL) {
                        if (Dynscat(&lp->lname, cp + 1, 0) == NULL)
                            goto memerr;
                        TVFSPathToLocalPath(lp->lname);
                    }
                }
            } else {
                cp = strrchr(lp->relname, '/');
                if (cp == NULL)
                    cp = strrchr(lp->relname, '\\');
                if (cp != NULL) {
                    cp++;
                } else {
                    cp = lp->relname;
                }
                if (Dynscat(&buf, cp, 0) == NULL)
                    goto memerr;
            }
        }
        lp->rname = buf;
        if (lp->rname == NULL) {
memerr:
            return (-1);
        }
        LocalPathToTVFSPath(lp->rname);
    }
    return (0);
}   /* ComputeRNames */

Referenced by FTPGetFiles3(), FTPPutFiles3(), FTPRemoteRecursiveFileList(), and FTPRemoteRecursiveFileList1().

◆ ConcatFileInfoList()

int ConcatFileInfoList	(	FileInfoListPtr	dst,
		FileInfoListPtr	src
	)

Definition at line 556 of file linelist.c.

{
    FileInfoPtr lp, lp2;
    FileInfo newfi;
 
    for (lp = src->first; lp != NULL; lp = lp2) {
        lp2 = lp->next;
        newfi = *lp;
        newfi.relname = StrDup(lp->relname);
        newfi.lname = StrDup(lp->lname);
        newfi.rname = StrDup(lp->rname);
        newfi.rlinkto = StrDup(lp->rlinkto);
        newfi.plug = StrDup(lp->plug);
        if (AddFileInfo(dst, &newfi) == NULL)
            return (-1);
    }
    return (0);
}   /* ConcatFileInfoList */

Referenced by FTPRemoteRecursiveFileList(), and FTPRemoteRecursiveFileList1().

◆ ConcatFileToFileInfoList()

int ConcatFileToFileInfoList	(	FileInfoListPtr	dst,
		char *	rfile
	)

Definition at line 740 of file linelist.c.

{
    FileInfo newfi;
 
    InitFileInfo(&newfi);   /* Use defaults. */
    newfi.relname = StrDup(rfile);
    newfi.rname = NULL;
    newfi.lname = NULL;
 
    if (AddFileInfo(dst, &newfi) == NULL)
        return (-1);
    return (0);
}   /* ConcatFileToFileInfoList */

Referenced by FTPRemoteRecursiveFileList(), FTPRemoteRecursiveFileList1(), LineListToFileInfoList(), and LineToFileInfoList().

◆ CopyLineList()

int CopyLineList	(	LineListPtr	dst,
		LineListPtr	src
	)

Definition at line 127 of file linelist.c.

{
    LinePtr lp, lp2;
 
    InitLineList(dst);
    for (lp = src->first; lp != NULL; ) {
        lp2 = lp;
        lp = lp->next;
        if (lp2->line != NULL) {
            if (AddLine(dst, lp2->line) == NULL) {
                DisposeLineListContents(dst);
                return (-1);
            }
        }
    }
    return (0);
}   /* CopyLineList */

Referenced by FTPRemoteHelp().

◆ DisposeFileInfoListContents()

void DisposeFileInfoListContents ( FileInfoListPtr list )

Definition at line 152 of file linelist.c.

{
    FileInfoPtr lp, lp2;
 
    for (lp = list->first; lp != NULL; ) {
        lp2 = lp;
        lp = lp->next;
        if (lp2->relname != NULL) {
            lp2->relname[0] = '\0';
            free(lp2->relname);
        }
        if (lp2->lname != NULL) {
            lp2->lname[0] = '\0';
            free(lp2->lname);
        }
        if (lp2->rname != NULL) {
            lp2->rname[0] = '\0';
            free(lp2->rname);
        }
        if (lp2->rlinkto != NULL) {
            lp2->rlinkto[0] = '\0';
            free(lp2->rlinkto);
        }
        if (lp2->plug != NULL) {
            lp2->plug[0] = '\0';
            free(lp2->plug);
        }
        free(lp2);
    }
 
    if (list->vec != NULL)
        free(list->vec);
 
    /* Same as InitFileInfoList. */
    (void) memset(list, 0, sizeof(FileInfoList));
}   /* DisposeFileInfoListContents */

Referenced by FlushLsCacheItem(), FTPGetFiles3(), FTPPutFiles3(), FTPRemoteRecursiveFileList(), and FTPRemoteRecursiveFileList1().

◆ DisposeLineListContents()

void DisposeLineListContents ( LineListPtr list )

Definition at line 33 of file linelist.c.

{
    LinePtr lp, lp2;
 
    for (lp = list->first; lp != NULL; ) {
        lp2 = lp;
        lp = lp->next;
        if (lp2->line != NULL) {
            lp2->line[0] = '\0';
            free(lp2->line);
        }
        free(lp2);
    }
    /* Same as InitLineList. */
    (void) memset(list, 0, sizeof(LineList));
}   /* DisposeLineListContents */

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.

{
    /* Dispose space taken up by the Response, and clear it out
     * again.  For some reason, I like to return memory to zeroed
     * when not in use.
     */
    if (rp != NULL) {
        TraceResponse(cip, rp);
        if (cip->printResponseProc != 0) {
            if ((rp->printMode & kResponseNoProc) == 0)
                (*cip->printResponseProc)(cip, rp);
        }
        if ((rp->printMode & kResponseNoSave) == 0)
            SaveLastResponse(cip, rp);
        else
            DisposeLineListContents(&rp->msg);
        (void) memset(rp, 0, sizeof(Response));
        free(rp);
    }
}   /* DoneWithResponse */

Referenced by FTPAbortDataTransfer(), FTPChdirAndGetCWD(), FTPCloseHost(), FTPCmd(), FTPEndDataCmd(), FTPFileExistsStat(), FTPFileModificationTime(), FTPFileSize(), FTPGetCWD(), FTPLoginHost(), FTPMListOneFile(), FTPQueryFeatures(), FTPRemoteHelp(), FTPStartDataCmd(), FTPUtime(), nFTPChdirAndGetCWD(), OpenControlConnection(), Passive(), SendPort(), and SetStartOffset().

◆ FGets()

char * FGets	(	char *	str,
		size_t	size,
		FILE *	fp
	)

Definition at line 111 of file util.c.

{
    char *cp, *nlptr;
 
    cp = fgets(str, ((int) size) - 1, fp);
    if (cp != NULL) {
        cp[((int) size) - 1] = '\0';    /* ensure terminator */
        nlptr = cp + strlen(cp) - 1;
        if (*nlptr == '\n')
            *nlptr = '\0';
    } else {
        memset(str, 0, size);
    }
    return cp;
}   /* FGets */

Referenced by GetBookmark(), GetNextBookmark(), LazyUnixLocalGlob(), OpenBookmarkFile(), PromptForBookmarkName(), PutBookmark(), and RunBookmarkEditor().

◆ FilenameExtensionIndicatesASCII()

int FilenameExtensionIndicatesASCII	(	const char *const	pathName,
		const char *const	extnList
	)

Definition at line 963 of file util.c.

{
    const char *extn;
    char *cp;
    int c;
    char extnPattern[16];
 
    extn = pathName + strlen(pathName) - 1;
    forever {
        if (extn <= pathName)
            return (0); /* End of pathname, no extension. */
        c = (int) *--extn;
        if (IsLocalPathDelim(c))
            return (0); /* End of filename, no extension. */
        if (c == '.') {
            extn += 1;
            break;
        }
    }
    if (strlen(extn) > (sizeof(extnPattern) - 2 - 1 - 1)) {
        return (0);
    }
#ifdef HAVE_SNPRINTF
    snprintf(extnPattern, sizeof(extnPattern),
#else
    sprintf(extnPattern,
#endif
        "|.%s|",
        extn
    );
 
    cp = extnPattern;
    forever {
        c = *cp;
        if (c == '\0')
            break;
        if (isupper(c)) {
            c = tolower(c);
            *cp++ = (char) c;
        } else {
            cp++;
        }
    }
 
    /* Extension list is specially formatted, like this:
     *
     *  |ext1|ext2|ext3|...|extN|
     *
     * I.e, each filename extension is delimited with
     * a pipe, and we always begin and end the string
     * with a pipe.
     */
    if (strstr(extnList, extnPattern) != NULL) {
        return (1);
    }
    return (0);
}   /* FilenameExtensionIndicatesASCII */

Referenced by AutomaticallyUseASCIIModeDependingOnExtension().

◆ FTPAbortDataTransfer()

void FTPAbortDataTransfer ( const FTPCIPtr cip )

Definition at line 870 of file rcmd.c.

{
    ResponsePtr rp;
    int result;
 
    if (cip->dataSocket != kClosedFileDescriptor) {
        PrintF(cip, "Starting abort sequence.\n");
        SendTelnetInterrupt(cip);       /* Probably could get by w/o doing this. */
 
        result = FTPCmdNoResponse(cip, "ABOR");
        if (result != kNoErr) {
            /* Linger could cause close to block, so unset it. */
            (void) SetLinger(cip, cip->dataSocket, 0);
            CloseDataConnection(cip);
            PrintF(cip, "Could not send abort command.\n");
            return;
        }
 
        if (cip->abortTimeout > 0) {
            result = WaitResponse(cip, (unsigned int) cip->abortTimeout);
            if (result <= 0) {
                /* Error or no response received to ABOR in time. */
                (void) SetLinger(cip, cip->dataSocket, 0);
                CloseDataConnection(cip);
                PrintF(cip, "No response received to abort request.\n");
                return;
            }
        }
 
        rp = InitResponse();
        if (rp == NULL) {
            Error(cip, kDontPerror, "Malloc failed.\n");
            cip->errNo = kErrMallocFailed;
            result = cip->errNo;
            return;
        }
 
        result = GetResponse(cip, rp);
        if (result < 0) {
            /* Shouldn't happen, and doesn't matter if it does. */
            (void) SetLinger(cip, cip->dataSocket, 0);
            CloseDataConnection(cip);
            PrintF(cip, "Invalid response to abort request.\n");
            DoneWithResponse(cip, rp);
            return;
        }
        DoneWithResponse(cip, rp);
 
        /* A response to the abort request has been received.
         * Now the only thing left to do is close the data
         * connection, making sure to turn off linger mode
         * since we don't care about straggling data bits.
         */
        (void) SetLinger(cip, cip->dataSocket, 0);
        CloseDataConnection(cip);       /* Must close (by protocol). */
        PrintF(cip, "End abort.\n");
    }
}   /* FTPAbortDataTransfer */

Referenced by FTPCloseHost(), FTPGetOneF(), and FTPPutOneF().

◆ FTPChdir()

int FTPChdir	(	const FTPCIPtr	cip,
		const char *const	cdCwd
	)

Definition at line 11 of file cmds.c.

{
    int result;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if (cdCwd == NULL) {
        result = kErrInvalidDirParam;
        cip->errNo = kErrInvalidDirParam;
    } else {
        if (cdCwd[0] == '\0')   /* But allow FTPChdir(cip, ".") to go through. */
            result = 2;
        else if (strcmp(cdCwd, "..") == 0)
            result = FTPCmd(cip, "CDUP");
        else
            result = FTPCmd(cip, "CWD %s", cdCwd);
        if (result >= 0) {
            if (result == 2) {
                result = kNoErr;
            } else {
                result = kErrCWDFailed;
                cip->errNo = kErrCWDFailed;
            }
        }
    }
    return (result);
}   /* 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.

{
    char *cp, *startcp;
    int result;
    int lastSubDir;
    int mkd, pwd;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if (cdCwd == NULL) {
        result = kErrInvalidDirParam;
        cip->errNo = kErrInvalidDirParam;
        return result;
    }
 
    if (flags == kChdirOnly)
        return (FTPChdir(cip, cdCwd));
    if (flags == kChdirAndGetCWD) {
        return (FTPChdirAndGetCWD(cip, cdCwd, newCwd, newCwdSize));
    } else if (flags == kChdirAndMkdir) {
        result = FTPMkdir(cip, cdCwd, kRecursiveYes);
        if (result == kNoErr)
            result = FTPChdir(cip, cdCwd);
        return result;
    } else if (flags == (kChdirAndMkdir|kChdirAndGetCWD)) {
        result = FTPMkdir(cip, cdCwd, kRecursiveYes);
        if (result == kNoErr)
            result = FTPChdirAndGetCWD(cip, cdCwd, newCwd, newCwdSize);
        return result;
    }
 
    /* else: (flags | kChdirOneSubdirAtATime) == true */
 
    cp = cip->buf;
    cp[cip->bufSize - 1] = '\0';
    (void) Strncpy(cip->buf, cdCwd, cip->bufSize);
    if (cp[cip->bufSize - 1] != '\0')
        return (kErrBadParameter);
 
    mkd = (flags & kChdirAndMkdir);
    pwd = (flags & kChdirAndGetCWD);
 
    if ((cdCwd[0] == '\0') || (strcmp(cdCwd, ".") == 0)) {
        result = 0;
        if (flags == kChdirAndGetCWD)
            result = FTPGetCWD(cip, newCwd, newCwdSize);
        return (result);
    }
 
    lastSubDir = 0;
    do {
        startcp = cp;
        cp = StrFindLocalPathDelim(cp);
        if (cp != NULL) {
            /* If this is the first slash in an absolute
             * path, then startcp will be empty.  We will
             * use this below to treat this as the root
             * directory.
             */
            *cp++ = '\0';
        } else {
            lastSubDir = 1;
        }
        if (strcmp(startcp, ".") == 0) {
            result = 0;
            if ((lastSubDir != 0) && (pwd != 0))
                result = FTPGetCWD(cip, newCwd, newCwdSize);
        } else if ((lastSubDir != 0) && (pwd != 0)) {
            result = FTPChdirAndGetCWD(cip, (*startcp != '\0') ? startcp : "/", newCwd, newCwdSize);
        } else {
            result = FTPChdir(cip, (*startcp != '\0') ? startcp : "/");
        }
        if (result < 0) {
            if ((mkd != 0) && (*startcp != '\0')) {
                if (FTPCmd(cip, "MKD %s", startcp) == 2) {
                    result = FTPChdir(cip, startcp);
                } else {
                    /* couldn't change nor create */
                    cip->errNo = result;
                }
            } else {
                cip->errNo = result;
            }
        }
    } while ((!lastSubDir) && (result == 0));
 
    return (result);
}   /* FTPChdir3 */

◆ 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.

{
    ResponsePtr rp;
    char *l, *r;
    int result;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if ((newCwd == NULL) || (cdCwd == NULL)) {
        result = kErrInvalidDirParam;
        cip->errNo = kErrInvalidDirParam;
    } else {
        if (cdCwd[0] == '\0') { /* But allow FTPChdir(cip, ".") to go through. */
            result = FTPGetCWD(cip, newCwd, newCwdSize);
            return (result);
        }
        rp = InitResponse();
        if (rp == NULL) {
            result = kErrMallocFailed;
            cip->errNo = kErrMallocFailed;
            Error(cip, kDontPerror, "Malloc failed.\n");
        } else {
            if (strcmp(cdCwd, "..") == 0)
                result = RCmd(cip, rp, "CDUP");
            else
                result = RCmd(cip, rp, "CWD %s", cdCwd);
            if (result == 2) {
                l = strchr(rp->msg.first->line, '"');
                if ((l == rp->msg.first->line) && ((r = strrchr(rp->msg.first->line, '"')) != NULL) && (l != r)) {
                    /* "xxxx" is current directory.
                     * Strip out just the xxxx to copy into the remote cwd.
                     *
                     * This is nice because we didn't have to do a PWD.
                     */
                    *r = '\0';
                    ++l;
                    (void) Strncpy(newCwd, l, newCwdSize);
                    *r = '"';   /* Restore, so response prints correctly. */
                    DoneWithResponse(cip, rp);
                    result = kNoErr;
                } else {
                    DoneWithResponse(cip, rp);
                    result = FTPGetCWD(cip, newCwd, newCwdSize);
                }
            } else if (result > 0) {
                result = kErrCWDFailed;
                cip->errNo = kErrCWDFailed;
                DoneWithResponse(cip, rp);
            } else {
                DoneWithResponse(cip, rp);
            }
        }
    }
    return (result);
}   /* 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.

{
    LineList fileList;
    LinePtr filePtr;
    char *file;
    int onceResult, batchResult;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    batchResult = FTPRemoteGlob(cip, &fileList, pattern, doGlob);
    if (batchResult != kNoErr)
        return (batchResult);
 
    for (batchResult = kNoErr, filePtr = fileList.first;
        filePtr != NULL;
        filePtr = filePtr->next)
    {
        file = filePtr->line;
        if (file == NULL) {
            batchResult = kErrBadLineList;
            cip->errNo = kErrBadLineList;
            break;
        }
        onceResult = FTPCmd(cip, "SITE CHMOD %s %s", mode, file);
        if (onceResult < 0) {
            batchResult = onceResult;
            break;
        }
        if (onceResult != 2) {
            batchResult = kErrChmodFailed;
            cip->errNo = kErrChmodFailed;
        }
    }
    DisposeLineListContents(&fileList);
    return (batchResult);
}   /* FTPChmod */

Referenced by ChmodCmd().

◆ FTPCloseHost()

int FTPCloseHost ( const FTPCIPtr cip )

Definition at line 523 of file open.c.

{
    ResponsePtr rp;
    int result;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    /* Data connection shouldn't be open normally. */
    if (cip->dataSocket != kClosedFileDescriptor)
        FTPAbortDataTransfer(cip);
 
    result = kNoErr;
    if (cip->connected != 0) {
        rp = InitResponse();
        if (rp == NULL) {
            cip->errNo = kErrMallocFailed;
            result = cip->errNo;
        } else {
            rp->eofOkay = 1;    /* We are expecting EOF after this cmd. */
            cip->eofOkay = 1;
            (void) RCmd(cip, rp, "QUIT");
            DoneWithResponse(cip, rp);
        }
    }
 
    CloseControlConnection(cip);
 
    /* Dispose dynamic data structures, so you won't leak
     * if you OpenHost with this again.
     */
    FTPDeallocateHost(cip);
    return (result);
}   /* FTPCloseHost */

Referenced by CloseHost(), and FTPOpenHost().

◆ FTPCmd()

int FTPCmd	(	const FTPCIPtr	cip,
		const char *const	cmdspec,
			...
	)

Definition at line 603 of file rcmd.c.

{
    va_list ap;
    int result;
    ResponsePtr rp;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    rp = InitResponse();
    if (rp == NULL) {
        result = kErrMallocFailed;
        cip->errNo = kErrMallocFailed;
        Error(cip, kDontPerror, "Malloc failed.\n");
        return (cip->errNo);
    }
 
    va_start(ap, cmdspec);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(cip->ctrlTimeout);
#endif  /* NO_SIGNALS */
    result = SendCommand(cip, cmdspec, ap);
    va_end(ap);
    if (result < 0) {
#ifndef NO_SIGNALS
        if (cip->ctrlTimeout > 0)
            (void) alarm(0);
#endif  /* NO_SIGNALS */
        return (result);
    }
 
    /* Get the response to the command we sent. */
    result = GetResponse(cip, rp);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(0);
#endif  /* NO_SIGNALS */
 
    if (result == kNoErr)
        result = rp->codeType;
    DoneWithResponse(cip, rp);
    return (result);
}   /* FTPCmd */

Referenced by DoOpen(), FTPChdir(), FTPChdir3(), FTPChmod(), FTPDelete(), FTPGetOneF(), FTPMkdir2(), FTPPutOneF(), FTPRename(), FTPRequestMlsOptions(), FTPRmdir(), FTPSetTransferType(), FTPSymlink(), FTPUmask(), QuoteCmd(), and SiteCmd().

◆ FTPCmdNoResponse()

int FTPCmdNoResponse	(	const	FTPCIPtr,
		const char *const	cmdspec,
			...
	)

Definition at line 656 of file rcmd.c.

{
    va_list ap;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    va_start(ap, cmdspec);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(cip->ctrlTimeout);
#endif  /* NO_SIGNALS */
    (void) SendCommand(cip, cmdspec, ap);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(0);
#endif  /* NO_SIGNALS */
    va_end(ap);
 
    return (kNoErr);
}   /* 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.

{
    char *cp;
    char *hstart, *hend;
    char *h2start;
    char *at1;
    char portstr[32];
    int port;
    int sc;
    char *lastslash;
    char *parsestr;
    char *tok;
    char subdir[128];
    char *semi;
 
    InitLineList(cdlist);
    *fn = '\0';
    if (wantnlst != NULL)
        *wantnlst = 0;
    if (xtype != NULL)
        *xtype = kTypeBinary;
 
    cp = NULL;  /* shut up warnings */
#ifdef HAVE_STRCASECMP
    if (strncasecmp(url, "<URL:ftp://", 11) == 0) {
        cp = url + strlen(url) - 1;
        if (*cp != '>')
            return (kMalformedURL); /* missing closing > */
        *cp = '\0';
        cp = url + 11;
    } else if (strncasecmp(url, "ftp://", 6) == 0) {
        cp = url + 6;
    } else {
        return (-1);        /* not a RFC 1738 URL */
    }
#else   /* HAVE_STRCASECMP */
    if (strncmp(url, "<URL:ftp://", 11) == 0) {
        cp = url + strlen(url) - 1;
        if (*cp != '>')
            return (kMalformedURL); /* missing closing > */
        *cp = '\0';
        cp = url + 11;
    } else if (strncmp(url, "ftp://", 6) == 0) {
        cp = url + 6;
    } else {
        return (-1);        /* not a RFC 1738 URL */
    }
#endif  /* HAVE_STRCASECMP */
 
    /* //<user>:<password>@<host>:<port>/<url-path> */
 
    at1 = NULL;
    for (hstart = cp; ; cp++) {
        if (*cp == '@') {
            if (at1 == NULL)
                at1 = cp;
            else
                return (kMalformedURL);
        } else if ((*cp == '\0') || (*cp == '/')) {
            hend = cp;
            break;
        }
    }
 
    sc = *hend;
    *hend = '\0';
    if (at1 == NULL) {
        /* no user or password */
        h2start = hstart;
    } else {
        *at1 = '\0';
        cp = strchr(hstart, ':');
        if (cp == NULL) {
            /* whole thing is the user name then */
            URLCopyToken(cip->user, sizeof(cip->user), hstart, (size_t) (at1 - hstart));
        } else if (strchr(cp + 1, ':') != NULL) {
            /* Too many colons */
            return (kMalformedURL);
        } else {
            URLCopyToken(cip->user, sizeof(cip->user), hstart, (size_t) (cp - hstart));
            URLCopyToken(cip->pass, sizeof(cip->pass), cp + 1, (size_t) (at1 - (cp + 1)));
        }
        *at1 = '@';
        h2start = at1 + 1;
    }
 
    cp = strchr(h2start, ':');
    if (cp == NULL) {
        /* whole thing is the host then */
        URLCopyToken(cip->host, sizeof(cip->host), h2start, (size_t) (hend - h2start));
    } else if (strchr(cp + 1, ':') != NULL) {
        /* Too many colons */
        return (kMalformedURL);
    } else {
        URLCopyToken(cip->host, sizeof(cip->host), h2start, (size_t) (cp - h2start));
        URLCopyToken(portstr, sizeof(portstr), cp + 1, (size_t) (hend - (cp + 1)));
        port = atoi(portstr);
        if (port > 0)
            cip->port = port;
    }
 
    *hend = (char) sc;
    if ((*hend == '\0') || ((*hend == '/') && (hend[1] == '\0'))) {
        /* no path, okay */
        return (0);
    }
 
    lastslash = strrchr(hend, '/');
    if (lastslash == NULL) {
        /* no path, okay */
        return (0);
    }
    *lastslash = '\0';
 
    if ((semi = strchr(lastslash + 1, ';')) != NULL) {
        *semi++ = '\0';
#ifdef HAVE_STRCASECMP
        if (strcasecmp(semi, "type=i") == 0) {
            if (xtype != NULL)
                *xtype = kTypeBinary;
        } else if (strcasecmp(semi, "type=a") == 0) {
            if (xtype != NULL)
                *xtype = kTypeAscii;
        } else if (strcasecmp(semi, "type=b") == 0) {
            if (xtype != NULL)
                *xtype = kTypeBinary;
        } else if (strcasecmp(semi, "type=d") == 0) {
            if (wantnlst != NULL) {
                *wantnlst = 1;
                if (xtype != NULL)
                    *xtype = kTypeAscii;
            } else {
                /* You didn't want these. */
                return (kMalformedURL);
            }
        }
#else   /* HAVE_STRCASECMP */
        if (strcmp(semi, "type=i") == 0) {
            if (xtype != NULL)
                *xtype = kTypeBinary;
        } else if (strcmp(semi, "type=a") == 0) {
            if (xtype != NULL)
                *xtype = kTypeAscii;
        } else if (strcmp(semi, "type=b") == 0) {
            if (xtype != NULL)
                *xtype = kTypeBinary;
        } else if (strcmp(semi, "type=d") == 0) {
            if (wantnlst != NULL) {
                *wantnlst = 1;
                if (xtype != NULL)
                    *xtype = kTypeAscii;
            } else {
                /* You didn't want these. */
                return (kMalformedURL);
            }
        }
#endif  /* HAVE_STRCASECMP */
    }
    URLCopyToken(fn, fnsize, lastslash + 1, strlen(lastslash + 1));
    for (parsestr = hend; (tok = strtok(parsestr, "/")) != NULL; parsestr = NULL) {
        URLCopyToken(subdir, sizeof(subdir), tok, strlen(tok));
        (void) AddLine(cdlist, subdir);
    }
    *lastslash = '/';
    return (kNoErr);
}   /* FTPDecodeURL */

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.

{
    LineList fileList;
    LinePtr filePtr;
    char *file;
    int onceResult, batchResult;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    batchResult = FTPRemoteGlob(cip, &fileList, pattern, doGlob);
    if (batchResult != kNoErr)
        return (batchResult);
 
    for (batchResult = kNoErr, filePtr = fileList.first;
        filePtr != NULL;
        filePtr = filePtr->next)
    {
        file = filePtr->line;
        if (file == NULL) {
            batchResult = kErrBadLineList;
            cip->errNo = kErrBadLineList;
            break;
        }
        onceResult = FTPCmd(cip, "DELE %s", file);
        if (onceResult < 0) {
            batchResult = onceResult;
            break;
        }
        if (onceResult != 2) {
            if (recurse != kRecursiveYes) {
                batchResult = kErrDELEFailed;
                cip->errNo = kErrDELEFailed;
            } else {
                onceResult = FTPCmd(cip, "RMD %s", file);
                if (onceResult < 0) {
                    batchResult = onceResult;
                    break;
                }
                if (onceResult != 2) {
                    onceResult = FTPRmdirRecursive(cip, file);
                    if (onceResult < 0) {
                        batchResult = kErrRMDFailed;
                        cip->errNo = kErrRMDFailed;
                    }
                }
            }
        }
    }
    DisposeLineListContents(&fileList);
    return (batchResult);
}   /* FTPDelete */

Referenced by DeleteCmd(), FTPGetOneF(), FTPPutOneF(), and FTPRmdirRecursiveL2().

◆ FTPEndDataCmd()

int FTPEndDataCmd	(	const	FTPCIPtr,
		int	didXfer
	)

Definition at line 933 of file rcmd.c.

{
    int result;
    int respCode;
    ResponsePtr rp;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    CloseDataConnection(cip);
    result = kNoErr;
    if (didXfer) {
        /* Get the response to the data transferred.  Most likely a message
         * saying that the transfer completed succesfully.  However, if
         * we tried to abort the transfer using ABOR, we will have a response
         * to that command instead.
         */
        rp = InitResponse();
        if (rp == NULL) {
            Error(cip, kDontPerror, "Malloc failed.\n");
            cip->errNo = kErrMallocFailed;
            result = cip->errNo;
            return (result);
        }
        result = GetResponse(cip, rp);
        if (result < 0)
            return (result);
        respCode = rp->codeType;
        DoneWithResponse(cip, rp);
        if (respCode != 2) {
            cip->errNo = kErrDataTransferFailed;
            result = cip->errNo;
        } else {
            result = kNoErr;
        }
    }
    return (result);
}   /* FTPEndDataCmd */

Referenced by FTPGetOneF(), FTPList(), FTPListToMemory2(), FTPPutOneF(), and FTPStartDataCmd().

◆ FTPFileExists()

int FTPFileExists	(	const FTPCIPtr	cip,
		const char *const	file
	)

Definition at line 1423 of file cmds.c.

{
    return (FTPFileExists2(cip, file, 1, 1, 1, 1, 1));
}   /* FTPFileExists */

◆ 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.

{
    int result;
    time_t mdtm;
    longest_int size;
    MLstItem mlsInfo;
 
    if (tryMDTM != 0) {
        result = FTPFileModificationTime(cip, file, &mdtm);
        if (result == kNoErr)
            return (kNoErr);
        if (result == kErrMDTMFailed) {
            cip->errNo = kErrNoSuchFileOrDirectory;
            return (kErrNoSuchFileOrDirectory);
        }
        /* else keep going */
    }
 
    if (trySIZE != 0) {
        result = FTPFileSize(cip, file, &size, kTypeBinary);
        if (result == kNoErr)
            return (kNoErr);
        /* SIZE could fail if the server does
         * not support it for directories.
         *
         * if (result == kErrSIZEFailed)
         *  return (kErrNoSuchFileOrDirectory);
         */
        /* else keep going */
    }
 
 
    if (tryMLST != 0) {
        result = FTPMListOneFile(cip, file, &mlsInfo);
        if (result == kNoErr)
            return (kNoErr);
        if (result == kErrMLSTFailed) {
            cip->errNo = kErrNoSuchFileOrDirectory;
            return (kErrNoSuchFileOrDirectory);
        }
        /* else keep going */
    }
 
    if (trySTAT != 0) {
        result = FTPFileExistsStat(cip, file);
        if (result == kNoErr)
            return (kNoErr);
        if (result == kErrSTATFailed) {
            cip->errNo = kErrNoSuchFileOrDirectory;
            return (kErrNoSuchFileOrDirectory);
        }
        /* else keep going */
    }
 
    if (tryNLST != 0) {
        result = FTPFileExistsNlst(cip, file);
        if (result == kNoErr)
            return (kNoErr);
        if (result == kErrNLSTFailed) {
            cip->errNo = kErrNoSuchFileOrDirectory;
            return (kErrNoSuchFileOrDirectory);
        }
        /* else keep going */
    }
 
    cip->errNo = kErrCantTellIfFileExists;
    return (kErrCantTellIfFileExists);
}   /* FTPFileExists2 */

Referenced by FTPFileExists(), FTPFileType(), and FTPPutOneF().

◆ FTPFileExistsNlst()

int FTPFileExistsNlst	(	const FTPCIPtr	cip,
		const char *const	file
	)

Definition at line 1209 of file cmds.c.

{
    int result;
    LineList fileList, rootFileList;
    char savedCwd[512];
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if (file == NULL)
        return (kErrBadParameter);
 
    if (cip->NLSTfileParamWorks == kCommandNotAvailable) {
        cip->errNo = result = kErrNLSTwithFileNotAvailable;
        return (result);
    }
 
    if (cip->NLSTfileParamWorks == kCommandAvailabilityUnknown) {
        /* First, make sure that when we NLST a pathname
         * that does not exist, that we get an error back.
         *
         * We also assume that a valid NLST response has
         * at least 3 lines of response text, typically
         * a "start" line, intermediate data, and then
         * a trailing line.
         *
         * We also can see a one-line case.
         */
        if (
            ((FTPListToMemory2(cip, "NoSuchFile", &fileList, "", 0, (int *) 0)) == kNoErr) &&
            (fileList.nLines >= 1) &&
            (strstr(fileList.last->line, "o such file") == NULL) &&
            (strstr(fileList.last->line, "ot found") == NULL) &&
            (strstr(fileList.last->line, "o Such File") == NULL) &&
            (strstr(fileList.last->line, "ot Found") == NULL)
 
        ) {
            cip->NLSTfileParamWorks = kCommandNotAvailable;
            cip->errNo = result = kErrNLSTwithFileNotAvailable;
            DisposeLineListContents(&fileList);
            return (result);
        }
        DisposeLineListContents(&fileList);
 
        /* We can't assume that we can simply say NLST rootdir/firstfile,
         * since the remote host may not be using / as a directory
         * delimiter.  So we have to change to the root directory
         * and then do the NLST on that file.
         */
        if (
            (FTPGetCWD(cip, savedCwd, sizeof(savedCwd)) != kNoErr) ||
            (FTPChdir(cip, cip->startingWorkingDirectory) != kNoErr)
        ) {
            return (cip->errNo);
        }
 
        /* OK, we get an error when we list
         * a non-existant file, but now we need to
         * see if we get a positive reply when
         * we stat a file that does exist.
         *
         * To do this, we list the root directory,
         * which we assume has one or more items.
         * If it doesn't, the user can't do anything
         * anyway.  Then we do the first item
         * we found to see if NLST says it exists.
         */
        if (
            ((result = FTPListToMemory2(cip, "", &rootFileList, "", 0, (int *) 0)) < 0) ||
            (rootFileList.last == NULL) ||
            (rootFileList.last->line == NULL)
        ) {
            /* Hmmm... well, in any case we can't use NLST. */
            cip->NLSTfileParamWorks = kCommandNotAvailable;
            cip->errNo = result = kErrNLSTwithFileNotAvailable;
            DisposeLineListContents(&rootFileList);
            (void) FTPChdir(cip, savedCwd);
            return (result);
        }
 
        if (
            ((FTPListToMemory2(cip, rootFileList.last->line, &fileList, "", 0, (int *) 0)) == kNoErr) &&
            (fileList.nLines >= 1) &&
            (strstr(fileList.last->line, "o such file") == NULL) &&
            (strstr(fileList.last->line, "ot found") == NULL) &&
            (strstr(fileList.last->line, "o Such File") == NULL) &&
            (strstr(fileList.last->line, "ot Found") == NULL)
 
        ) {
            /* Good.  We listed the item. */
            DisposeLineListContents(&fileList);
            DisposeLineListContents(&rootFileList);
            cip->NLSTfileParamWorks = kCommandAvailable;
 
            /* Don't forget to change back to the original directory. */
            (void) FTPChdir(cip, savedCwd);
        } else {
            cip->NLSTfileParamWorks = kCommandNotAvailable;
            cip->errNo = result = kErrNLSTwithFileNotAvailable;
            DisposeLineListContents(&fileList);
            DisposeLineListContents(&rootFileList);
            (void) FTPChdir(cip, savedCwd);
            return (result);
        }
    }
 
    /* Check the requested item. */
    InitLineList(&fileList);
    if (
        ((FTPListToMemory2(cip, file, &fileList, "", 0, (int *) 0)) == kNoErr) &&
        (fileList.nLines >= 1) &&
        (strstr(fileList.last->line, "o such file") == NULL) &&
        (strstr(fileList.last->line, "ot found") == NULL) &&
        (strstr(fileList.last->line, "o Such File") == NULL) &&
        (strstr(fileList.last->line, "ot Found") == NULL)
 
    ) {
        /* The item existed. */
        result = kNoErr;
    } else {
        cip->errNo = kErrNLSTFailed;
        result = kErrNLSTFailed;
    }
 
    DisposeLineListContents(&fileList);
    return (result);
}   /* FTPFileExistsNlst*/

Referenced by FTPFileExists2().

◆ FTPFileExistsStat()

int FTPFileExistsStat	(	const FTPCIPtr	cip,
		const char *const	file
	)

Definition at line 1008 of file cmds.c.

{
    int result;
    ResponsePtr rp;
    LineList fileList;
    char savedCwd[512];
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if (file == NULL)
        return (kErrBadParameter);
 
    if (cip->STATfileParamWorks == kCommandNotAvailable) {
        cip->errNo = result = kErrSTATwithFileNotAvailable;
        return (result);
    }
 
    if (cip->STATfileParamWorks == kCommandAvailabilityUnknown) {
        rp = InitResponse();
        if (rp == NULL) {
            result = kErrMallocFailed;
            cip->errNo = kErrMallocFailed;
            Error(cip, kDontPerror, "Malloc failed.\n");
            return (result);
 
        }
 
        /* First, make sure that when we STAT a pathname
         * that does not exist, that we get an error back.
         *
         * We also assume that a valid STAT response has
         * at least 3 lines of response text, typically
         * a "start" line, intermediate data, and then
         * a trailing line.
         *
         * We also can see a one-line case.
         */
        result = RCmd(cip, rp, "STAT %s", "NoSuchFile");
        if ((result == 2) && ((rp->msg.nLines >= 3) || (rp->msg.nLines == 1))) {
            /* Hmmm.... it gave back a positive
             * response.  So STAT <file> does not
             * work correctly.
             */
            if (
                (rp->msg.first->next != NULL) &&
                (rp->msg.first->next->line != NULL) &&
                (
                    (strstr(rp->msg.first->next->line, "o such file") != NULL) ||
                    (strstr(rp->msg.first->next->line, "ot found") != NULL)
                )
            ) {
                /* OK, while we didn't want a 200
                 * level response, some servers,
                 * like wu-ftpd print an error
                 * message "No such file or
                 * directory" which we can special
                 * case.
                 */
                result = kNoErr;
            } else {
                cip->STATfileParamWorks = kCommandNotAvailable;
                cip->errNo = result = kErrSTATwithFileNotAvailable;
                DoneWithResponse(cip, rp);
                return (result);
            }
        }
        DoneWithResponse(cip, rp);
 
        /* We can't assume that we can simply say STAT rootdir/firstfile,
         * since the remote host may not be using / as a directory
         * delimiter.  So we have to change to the root directory
         * and then do the STAT on that file.
         */
        if (
            (FTPGetCWD(cip, savedCwd, sizeof(savedCwd)) != kNoErr) ||
            (FTPChdir(cip, cip->startingWorkingDirectory) != kNoErr)
        ) {
            return (cip->errNo);
        }
 
        /* OK, we get an error when we stat
         * a non-existant file, but now we need to
         * see if we get a positive reply when
         * we stat a file that does exist.
         *
         * To do this, we list the root directory,
         * which we assume has one or more items.
         * If it doesn't, the user can't do anything
         * anyway.  Then we stat the first item
         * we found to see if STAT says it exists.
         */
        if (
            ((result = FTPListToMemory2(cip, "", &fileList, "", 0, (int *) 0)) < 0) ||
            (fileList.last == NULL) ||
            (fileList.last->line == NULL)
        ) {
            /* Hmmm... well, in any case we can't use STAT. */
            cip->STATfileParamWorks = kCommandNotAvailable;
            cip->errNo = result = kErrSTATwithFileNotAvailable;
            DisposeLineListContents(&fileList);
            (void) FTPChdir(cip, savedCwd);
            return (result);
        }
 
        rp = InitResponse();
        if (rp == NULL) {
            result = kErrMallocFailed;
            cip->errNo = kErrMallocFailed;
            Error(cip, kDontPerror, "Malloc failed.\n");
            DisposeLineListContents(&fileList);
            (void) FTPChdir(cip, savedCwd);
            return (result);
 
        }
 
        result = RCmd(cip, rp, "STAT %s", fileList.last->line);
        DisposeLineListContents(&fileList);
 
        if ((result != 2) || (rp->msg.nLines == 2)) {
            /* Hmmm.... it gave back a negative
             * response.  So STAT <file> does not
             * work correctly.
             */
            cip->STATfileParamWorks = kCommandNotAvailable;
            cip->errNo = result = kErrSTATwithFileNotAvailable;
            DoneWithResponse(cip, rp);
            (void) FTPChdir(cip, savedCwd);
            return (result);
        } else if (
                (rp->msg.first->next != NULL) &&
                (rp->msg.first->next->line != NULL) &&
                (
                    (strstr(rp->msg.first->next->line, "o such file") != NULL) ||
                    (strstr(rp->msg.first->next->line, "ot found") != NULL)
                )
        ) {
            /* Same special-case of the second line of STAT response. */
            cip->STATfileParamWorks = kCommandNotAvailable;
            cip->errNo = result = kErrSTATwithFileNotAvailable;
            DoneWithResponse(cip, rp);
            (void) FTPChdir(cip, savedCwd);
            return (result);
        }
        DoneWithResponse(cip, rp);
        cip->STATfileParamWorks = kCommandAvailable;
 
        /* Don't forget to change back to the original directory. */
        (void) FTPChdir(cip, savedCwd);
    }
 
    rp = InitResponse();
    if (rp == NULL) {
        result = kErrMallocFailed;
        cip->errNo = kErrMallocFailed;
        Error(cip, kDontPerror, "Malloc failed.\n");
        return (result);
    }
 
    result = RCmd(cip, rp, "STAT %s", file);
    if (result == 2) {
        result = kNoErr;
        if (((rp->msg.nLines >= 3) || (rp->msg.nLines == 1))) {
            if (
                (rp->msg.first->next != NULL) &&
                (rp->msg.first->next->line != NULL) &&
                (
                    (strstr(rp->msg.first->next->line, "o such file") != NULL) ||
                    (strstr(rp->msg.first->next->line, "ot found") != NULL)
                )
            ) {
                cip->errNo = kErrSTATFailed;
                result = kErrSTATFailed;
            } else {
                result = kNoErr;
            }
        } else if (rp->msg.nLines == 2) {
            cip->errNo = kErrSTATFailed;
            result = kErrSTATFailed;
        } else {
            result = kNoErr;
        }
    } else {
        cip->errNo = kErrSTATFailed;
        result = kErrSTATFailed;
    }
    DoneWithResponse(cip, rp);
    return (result);
}   /* FTPFileExistsStat */

Referenced by FTPFileExists2().

◆ FTPFileModificationTime()

int FTPFileModificationTime	(	const FTPCIPtr	cip,
		const char *const	file,
		time_t *const	mdtm
	)

Definition at line 649 of file cmds.c.

{
    int result;
    ResponsePtr rp;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if ((mdtm == NULL) || (file == NULL))
        return (kErrBadParameter);
    *mdtm = kModTimeUnknown;
 
    if (cip->hasMDTM == kCommandNotAvailable) {
        cip->errNo = kErrMDTMNotAvailable;
        result = kErrMDTMNotAvailable;
    } else {
        rp = InitResponse();
        if (rp == NULL) {
            result = kErrMallocFailed;
            cip->errNo = kErrMallocFailed;
            Error(cip, kDontPerror, "Malloc failed.\n");
        } else {
            result = RCmd(cip, rp, "MDTM %s", file);
            if (result < 0) {
                DoneWithResponse(cip, rp);
                return (result);
            } else if (strncmp(rp->msg.first->line, "19100", 5) == 0) {
                Error(cip, kDontPerror, "Warning: Server has Y2K Bug in \"MDTM\" command.\n");
                cip->errNo = kErrMDTMFailed;
                result = kErrMDTMFailed;
            } else if (result == 2) {
                *mdtm = UnMDTMDate(rp->msg.first->line);
                cip->hasMDTM = kCommandAvailable;
                result = kNoErr;
            } else if (UNIMPLEMENTED_CMD(rp->code)) {
                cip->hasMDTM = kCommandNotAvailable;
                cip->errNo = kErrMDTMNotAvailable;
                result = kErrMDTMNotAvailable;
            } else {
                cip->errNo = kErrMDTMFailed;
                result = kErrMDTMFailed;
            }
            DoneWithResponse(cip, rp);
        }
    }
    return (result);
}   /* 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.

{
    int result;
    ResponsePtr rp;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if ((size == NULL) || (file == NULL))
        return (kErrBadParameter);
    *size = kSizeUnknown;
 
    result = FTPSetTransferType(cip, type);
    if (result < 0)
        return (result);
 
    if (cip->hasSIZE == kCommandNotAvailable) {
        cip->errNo = kErrSIZENotAvailable;
        result = kErrSIZENotAvailable;
    } else {
        rp = InitResponse();
        if (rp == NULL) {
            result = kErrMallocFailed;
            cip->errNo = kErrMallocFailed;
            Error(cip, kDontPerror, "Malloc failed.\n");
        } else {
            result = RCmd(cip, rp, "SIZE %s", file);
            if (result < 0) {
                DoneWithResponse(cip, rp);
                return (result);
            } else if (result == 2) {
#if defined(HAVE_LONG_LONG) && defined(SCANF_LONG_LONG)
                (void) sscanf(rp->msg.first->line, SCANF_LONG_LONG, size);
#elif defined(HAVE_LONG_LONG) && defined(HAVE_STRTOQ)
                *size = (longest_int) strtoq(rp->msg.first->line, NULL, 0);
#else
                (void) sscanf(rp->msg.first->line, "%ld", size);
#endif
                cip->hasSIZE = kCommandAvailable;
                result = kNoErr;
            } else if (UNIMPLEMENTED_CMD(rp->code)) {
                cip->hasSIZE = kCommandNotAvailable;
                cip->errNo = kErrSIZENotAvailable;
                result = kErrSIZENotAvailable;
            } else {
                cip->errNo = kErrSIZEFailed;
                result = kErrSIZEFailed;
            }
            DoneWithResponse(cip, rp);
        }
    }
    return (result);
}   /* FTPFileSize */

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.

{
    MLstItem mlsInfo;
    int result;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if ((mdtm == NULL) || (size == NULL) || (file == NULL))
        return (kErrBadParameter);
 
    *mdtm = kModTimeUnknown;
    *size = kSizeUnknown;
 
    result = FTPSetTransferType(cip, type);
    if (result < 0)
        return (result);
 
    result = FTPMListOneFile(cip, file, &mlsInfo);
    if (result < 0) {
        /* Do it the regular way, where
         * we do a SIZE and then a MDTM.
         */
        result = FTPFileSize(cip, file, size, type);
        if (result < 0)
            return (result);
        result = FTPFileModificationTime(cip, file, mdtm);
        return (result);
    } else {
        *mdtm = mlsInfo.ftime;
        *size = mlsInfo.fsize;
    }
 
    return (result);
}   /* FTPFileSizeAndModificationTime */

Referenced by FTPGetOneF(), and FTPPutOneF().

◆ FTPFileType()

int FTPFileType	(	const FTPCIPtr	cip,
		const char *const	file,
		int *const	ftype
	)

Definition at line 1475 of file cmds.c.

{
    int result;
    MLstItem mlsInfo;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if ((file == NULL) || (file[0] == '\0')) {
        cip->errNo = kErrBadParameter;
        return (kErrBadParameter);
    }
 
    if (ftype == NULL) {
        cip->errNo = kErrBadParameter;
        return (kErrBadParameter);
    }
 
    *ftype = 0;
    result = FTPMListOneFile(cip, file, &mlsInfo);
    if (result == kNoErr) {
        *ftype = mlsInfo.ftype;
        return (kNoErr);
    }
 
    /* Preserve old working directory. */
    (void) FTPGetCWD(cip, cip->buf, cip->bufSize);
 
    result = FTPChdir(cip, file);
    if (result == kNoErr) {
        *ftype = 'd';
        /* Yes it was a directory, now go back to
         * where we were.
         */
        (void) FTPChdir(cip, cip->buf);
 
        /* Note:  This improperly assumes that we
         * will be able to chdir back, which is
         * not guaranteed.
         */
        return (kNoErr);
    }
 
    result = FTPFileExists2(cip, file, 1, 1, 0, 1, 1);
    if (result != kErrNoSuchFileOrDirectory)
        result = kErrFileExistsButCannotDetermineType;
 
    return (result);
}   /* FTPFileType */

Referenced by FTPIsDir(), and FTPIsRegularFile().

◆ FTPFtw()

int FTPFtw	(	const FTPCIPtr	cip,
		const char *const	dir,
		FTPFtwProc	proc,
		int	maxdepth
	)

Definition at line 1706 of file glob.c.

{
    int result, result2;
    char *cp;
    char savedcwd[1024];
    char curcwd[2048];
 
    result = FTPIsDir(cip, dir);
    if (result < 0) {
        /* error */
        return result;
    } else if (result == 0) {
        result = cip->errNo = kErrNotADirectory;
        return (result);
    }
 
    /* Preserve old working directory. */
    (void) FTPGetCWD(cip, savedcwd, sizeof(savedcwd));
 
    result = FTPChdir(cip, dir);
    if (result != kNoErr) {
        return (result);
    }
 
    /* Get full working directory we just changed to. */
    result = FTPGetCWD(cip, curcwd, sizeof(curcwd) - 3);
    if (result != kNoErr) {
        if (FTPChdir(cip, savedcwd) != kNoErr) {
            result = kErrCannotGoToPrevDir;
            cip->errNo = kErrCannotGoToPrevDir;
        }
        return (result);
    }
 
    result2 = (*proc)(cip, curcwd, kFtwDir);
    if (result2 == kNoErr) {
        cp = curcwd + strlen(curcwd);
 
        if ((strchr(curcwd, '/') == NULL) && (strrchr(curcwd, '\\') != NULL))
            *cp++ = '\\';
        else
            *cp++ = '/';
        *cp = '\0';
        result = FTPFtwL2(cip, curcwd, cp, sizeof(curcwd), proc, maxdepth - 1);
    }
 
 
    if (FTPChdir(cip, savedcwd) != kNoErr) {
        /* Could not cd back to the original user directory -- bad. */
        result = kErrCannotGoToPrevDir;
        cip->errNo = kErrCannotGoToPrevDir;
        return (result);
    }
 
    if ((result2 != kNoErr) && (result == kNoErr))
        result = result2;
 
    return (result);
}   /* FTPFtw */

◆ FTPGetCWD()

int FTPGetCWD	(	const FTPCIPtr	cip,
		char *const	newCwd,
		const size_t	newCwdSize
	)

Definition at line 254 of file cmds.c.

{
    ResponsePtr rp;
    char *l, *r;
    int result;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if ((newCwd == NULL) || (newCwdSize == 0)) {
        result = kErrInvalidDirParam;
        cip->errNo = kErrInvalidDirParam;
    } else {
        rp = InitResponse();
        if (rp == NULL) {
            result = kErrMallocFailed;
            cip->errNo = kErrMallocFailed;
            Error(cip, kDontPerror, "Malloc failed.\n");
        } else {
            result = RCmd(cip, rp, "PWD");
            if (result == 2) {
                if ((r = strrchr(rp->msg.first->line, '"')) != NULL) {
                    /* "xxxx" is current directory.
                     * Strip out just the xxxx to copy into the remote cwd.
                     */
                    l = strchr(rp->msg.first->line, '"');
                    if ((l != NULL) && (l != r)) {
                        *r = '\0';
                        ++l;
                        (void) Strncpy(newCwd, l, newCwdSize);
                        *r = '"';   /* Restore, so response prints correctly. */
                    }
                } else {
                    /* xxxx is current directory.
                     * Mostly for VMS.
                     */
                    if ((r = strchr(rp->msg.first->line, ' ')) != NULL) {
                        *r = '\0';
                        (void) Strncpy(newCwd, (rp->msg.first->line), newCwdSize);
                        *r = ' ';   /* Restore, so response prints correctly. */
                    }
                }
                result = kNoErr;
            } else if (result > 0) {
                result = kErrPWDFailed;
                cip->errNo = kErrPWDFailed;
            }
            DoneWithResponse(cip, rp);
        }
    }
    return (result);
}   /* 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.

{
    return (FTPGetFiles3(cip, pattern, dstdir, recurse, doGlob, kTypeBinary, kResumeNo, kAppendNo, kDeleteNo, kTarYes, (ConfirmResumeDownloadProc) 0, 0));
}   /* FTPGetFiles */

◆ 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.

{
    return (FTPGetFiles3(cip, pattern, dstdir, recurse, doGlob, xtype, resumeflag, appendflag, kDeleteNo, kTarYes, (ConfirmResumeDownloadProc) 0, 0));
}   /* 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.

{
    return (FTPGetFiles3(cip, pattern, dstdir, recurse, doGlob, kTypeAscii, kResumeNo, kAppendNo, kDeleteNo, kTarNo, (ConfirmResumeDownloadProc) 0, 0));
}   /* FTPGetFilesAscii */

◆ FTPGetLocalCWD()

char * FTPGetLocalCWD	(	char *	buf,
		size_t	size
	)

Definition at line 29 of file util.c.

{
#ifdef HAVE_GETCWD
    static char *cwdBuf = NULL;
    static size_t cwdBufSize = 0;
 
    if (cwdBufSize == 0) {
        cwdBufSize = (size_t) 128;
        cwdBuf = (char *) malloc(cwdBufSize);
    }
 
    for (errno = 0; ; ) {
        if (cwdBuf == NULL) {
            return NULL;
        }
 
        if (getcwd(cwdBuf, cwdBufSize) != NULL)
            break;
        if (errno != ERANGE) {
            (void) Strncpy(buf, ".", size);
            return NULL;
        }
        cwdBufSize *= 2;
        cwdBuf = (char *) Realloc(cwdBuf, cwdBufSize);
    }
 
    return (Strncpy(buf, cwdBuf, size));
#else
#ifdef HAVE_GETWD
    static char *cwdBuf = NULL;
    char *dp;
 
    /* Due to the way getwd is usually implemented, it's
     * important to have a buffer large enough to hold the
     * whole thing.  getwd usually starts at the end of the
     * buffer, and works backwards, returning you a pointer
     * to the beginning of it when it finishes.
     */
    if (size < MAXPATHLEN) {
        /* Buffer not big enough, so use a temporary one,
         * and then copy the first 'size' bytes of the
         * temporary buffer to your 'buf.'
         */
        if (cwdBuf == NULL) {
            cwdBuf = (char *) malloc((size_t) MAXPATHLEN);
            if (cwdBuf == NULL) {
                return NULL;
            }
        }
        dp = cwdBuf;
    } else {
        /* Buffer is big enough already. */
        dp = buf;
    }
    *dp = '\0';
    if (getwd(dp) == NULL) {
        /* getwd() should write the reason why in the buffer then,
         * according to the man pages.
         */
        (void) Strncpy(buf, ".", size);
        return (NULL);
    }
    return (Strncpy(buf, dp, size));
 
#elif defined(WIN32) || defined(_WINDOWS)
    if (GetCurrentDirectory((DWORD) size - 1, buf) < 1)
        return NULL;
    buf[size - 1] = '\0';
    return buf;
#else
    /* Not a solution, but does anybody not have either of
     * getcwd or getwd?
     */
    --Error--;
#endif
#endif
}   /* GetCWD */

Referenced by DoOpen(), LocalChdirCmd(), LocalPwdCmd(), PostInit(), SpoolGetCmd(), SpoolPutCmd(), and SpoolX().

◆ FTPGetOneFile()

int FTPGetOneFile	(	const FTPCIPtr	cip,
		const char *const	file,
		const char *const	dstfile
	)

Definition at line 2712 of file io.c.

{
    return (FTPGetOneFile3(cip, file, dstfile, kTypeBinary, -1, kResumeNo, kAppendNo, kDeleteNo, (ConfirmResumeDownloadProc) 0, 0));
}   /* FTPGetOneFile */

◆ 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.

{
    return (FTPGetOneFile3(cip, file, dstfile, xtype, fdtouse, resumeflag, appendflag, kDeleteNo, (ConfirmResumeDownloadProc) 0, 0));
}   /* FTPGetOneFile2 */

Referenced by CatCmd(), and PageCmd().

◆ 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()

int FTPGetOneFileAscii	(	const FTPCIPtr	cip,
		const char *const	file,
		const char *const	dstfile
	)

Definition at line 2748 of file io.c.

{
    return (FTPGetOneFile3(cip, file, dstfile, kTypeAscii, -1, kResumeNo, kAppendNo, kDeleteNo, (ConfirmResumeDownloadProc) 0, 0));
}   /* FTPGetOneFileAscii */

◆ FTPInitConnectionInfo()

int FTPInitConnectionInfo	(	const FTPLIPtr	lip,
		const FTPCIPtr	cip,
		size_t	bufsize
	)

Definition at line 984 of file open.c.

{
    size_t siz;
 
    if ((lip == NULL) || (cip == NULL) || (bufSize == 0))
        return (kErrBadParameter);
 
    siz = sizeof(FTPConnectionInfo);
    (void) memset(cip, 0, siz);
 
    if (strcmp(lip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    cip->buf = NULL;    /* denote that it needs to be allocated. */
    cip->bufSize = bufSize;
    cip->port = lip->defaultPort;
    cip->firewallPort = lip->defaultPort;
    cip->maxDials = kDefaultMaxDials;
    cip->redialDelay = kDefaultRedialDelay;
    cip->xferTimeout = kDefaultXferTimeout;
    cip->connTimeout = kDefaultConnTimeout;
    cip->ctrlTimeout = kDefaultCtrlTimeout;
    cip->abortTimeout = kDefaultAbortTimeout;
    cip->ctrlSocketR = kClosedFileDescriptor;
    cip->ctrlSocketW = kClosedFileDescriptor;
    cip->dataPortMode = kSendPortMode;
    cip->dataSocket = kClosedFileDescriptor;
    cip->lip = lip;
    cip->hasPASV = kCommandAvailabilityUnknown;
    cip->hasSIZE = kCommandAvailabilityUnknown;
    cip->hasMDTM = kCommandAvailabilityUnknown;
    cip->hasREST = kCommandAvailabilityUnknown;
    cip->hasNLST_d = kCommandAvailabilityUnknown;
    cip->hasUTIME = kCommandAvailabilityUnknown;
    cip->hasFEAT = kCommandAvailabilityUnknown;
    cip->hasMLSD = kCommandAvailabilityUnknown;
    cip->hasMLST = kCommandAvailabilityUnknown;
    cip->hasCLNT = kCommandAvailabilityUnknown;
    cip->hasRETRBUFSIZE = kCommandAvailabilityUnknown;
    cip->hasRBUFSIZ = kCommandAvailabilityUnknown;
    cip->hasRBUFSZ = kCommandAvailabilityUnknown;
    cip->hasSTORBUFSIZE = kCommandAvailabilityUnknown;
    cip->hasSBUFSIZ = kCommandAvailabilityUnknown;
    cip->hasSBUFSZ = kCommandAvailabilityUnknown;
    cip->STATfileParamWorks = kCommandAvailabilityUnknown;
    cip->NLSTfileParamWorks = kCommandAvailabilityUnknown;
    cip->firewallType = kFirewallNotInUse;
    cip->startingWorkingDirectory = NULL;
    (void) STRNCPY(cip->magic, kLibraryMagic);
    (void) STRNCPY(cip->user, "anonymous");
    return (kNoErr);
}   /* FTPInitConnectionInfo */

Referenced by InitConnectionInfo().

◆ FTPInitializeAnonPassword()

void FTPInitializeAnonPassword ( const FTPLIPtr )

Definition at line 81 of file open.c.

{
    if (lip == NULL)
        return;
    if (strcmp(lip->magic, kLibraryMagic))
        return;
 
    FTPInitializeOurHostName(lip);
 
    if (lip->defaultAnonPassword[0] == '\0') {
#ifdef SPAM_PROBLEM_HAS_BEEN_SOLVED_FOREVER
        GetUsrName(lip->defaultAnonPassword, sizeof(lip->defaultAnonPassword));
        (void) STRNCAT(lip->defaultAnonPassword, "@");
 
        /* Default to the "user@" notation
         * supported by NcFTPd and wu-ftpd.
         */
        if (lip->htried > 0)
            (void) STRNCAT(lip->defaultAnonPassword, lip->ourHostName);
#else
        (void) STRNCPY(lip->defaultAnonPassword, "NcFTP@");
#endif
    }
}   /* FTPInitializeAnonPassword */

Referenced by FTPLoginHost(), and PostInitPrefs().

◆ FTPInitializeOurHostName()

void FTPInitializeOurHostName ( const FTPLIPtr )

Definition at line 63 of file open.c.

{
    if (lip == NULL)
        return;
    if (strcmp(lip->magic, kLibraryMagic))
        return;
 
    if (lip->htried == 0) {
        (void) memset(lip->ourHostName, 0, sizeof(lip->ourHostName));
        lip->hresult = GetOurHostName(lip->ourHostName, sizeof(lip->ourHostName));
    }
    lip->htried++;
}   /* FTPInitializeOurHostName */

Referenced by FTPInitializeAnonPassword(), LoadFirewallPrefs(), OpenTrace(), and WriteDefaultFirewallPrefs().

◆ FTPInitIOTimer()

void FTPInitIOTimer ( const FTPCIPtr )

Definition at line 71 of file io.c.

{
    cip->bytesTransferred = (longest_int) 0;
    cip->expectedSize = kSizeUnknown;
    cip->mdtm = kModTimeUnknown;
    cip->rname = NULL;
    cip->lname = NULL;
    cip->kBytesPerSec = -1.0;
    cip->percentCompleted = -1.0;
    cip->sec = -1.0;
    cip->secLeft = -1.0;
    cip->nextProgressUpdate = 0;
    cip->stalled = 0;
    cip->dataTimedOut = 0;
    cip->useProgressMeter = 1;
    (void) gettimeofday(&cip->t0, NULL);
}   /* FTPInitIOTimer */

Referenced by FTPGetOneF(), and FTPPutOneF().

◆ FTPInitLibrary()

int FTPInitLibrary ( const FTPLIPtr lip )

Definition at line 1110 of file open.c.

{
    struct servent *ftp;
 
    if (lip == NULL)
        return (kErrBadParameter);
 
    (void) memset(lip, 0, sizeof(FTPLibraryInfo));
    if ((ftp = getservbyname("ftp", "tcp")) == NULL)
        lip->defaultPort = (unsigned int) kDefaultFTPPort;
    else
        lip->defaultPort = (unsigned int) ntohs(ftp->s_port);
 
    lip->init = 1;
    (void) STRNCPY(lip->magic, kLibraryMagic);
 
    /* We'll initialize the defaultAnonPassword field
     * later when we try the first anon ftp connection.
     */
 
#ifdef HAVE_LIBSOCKS
    SOCKSinit("libncftp");
    lip->socksInit = 1;
#endif
    return (kNoErr);
}   /* FTPInitLibrary */

Referenced by PreInit().

◆ FTPIsDir()

int FTPIsDir	(	const FTPCIPtr	cip,
		const char *const	dir
	)

Definition at line 1531 of file cmds.c.

{
    int result, ftype;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if ((dir == NULL) || (dir[0] == '\0')) {
        cip->errNo = kErrInvalidDirParam;
        return (kErrInvalidDirParam);
    }
 
    result = FTPFileType(cip, dir, &ftype);
    if ((result == kNoErr) || (result == kErrFileExistsButCannotDetermineType)) {
        result = 0;
        if (ftype == 'd')
            result = 1;
    }
    return (result);
}   /* FTPIsDir */

Referenced by FTPFtw(), FTPFtwL2(), and FTPGetFiles3().

◆ FTPIsRegularFile()

int FTPIsRegularFile	(	const FTPCIPtr	cip,
		const char *const	file
	)

Definition at line 1558 of file cmds.c.

{
    int result, ftype;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if ((file == NULL) || (file[0] == '\0')) {
        cip->errNo = kErrBadParameter;
        return (kErrBadParameter);
    }
 
    result = FTPFileType(cip, file, &ftype);
    if ((result == kNoErr) || (result == kErrFileExistsButCannotDetermineType)) {
        result = 1;
        if (ftype == 'd')
            result = 0;
    }
    return (result);
}   /* FTPIsRegularFile */

◆ FTPList()

int FTPList	(	const FTPCIPtr	cip,
		const int	outfd,
		const int	longMode,
		const char *const	lsflag
	)

Definition at line 174 of file io.c.

{
    const char *cmd;
    char line[512];
    char secondaryBuf[768];
#ifndef NO_SIGNALS
    char *secBufPtr, *secBufLimit;
    int nread;
    volatile int result;
#else   /* NO_SIGNALS */
    SReadlineInfo lsSrl;
    int result;
#endif  /* NO_SIGNALS */
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    cmd = (longMode != 0) ? "LIST" : "NLST";
    if ((lsflag == NULL) || (lsflag[0] == '\0')) {
        result = FTPStartDataCmd(cip, kNetReading, kTypeAscii, (longest_int) 0, "%s", cmd);
    } else {
        result = FTPStartDataCmd(cip, kNetReading, kTypeAscii, (longest_int) 0, "%s %s", cmd, lsflag);
    }
 
 
#ifdef NO_SIGNALS
 
    if (result == 0) {
        if (InitSReadlineInfo(&lsSrl, cip->dataSocket, secondaryBuf, sizeof(secondaryBuf), (int) cip->xferTimeout, 1) < 0) {
            /* Not really fdopen, but close in what we're trying to do. */
            result = kErrFdopenR;
            cip->errNo = kErrFdopenR;
            Error(cip, kDoPerror, "Could not fdopen.\n");
            return (result);
        }
 
        for (;;) {
            result = SReadline(&lsSrl, line, sizeof(line) - 2);
            if (result == kTimeoutErr) {
                /* timeout */
                Error(cip, kDontPerror, "Could not directory listing data -- timed out.\n");
                cip->errNo = kErrDataTimedOut;
                return (cip->errNo);
            } else if (result == 0) {
                /* end of listing -- done */
                cip->numListings++;
                break;
            } else if (result < 0) {
                /* error */
                Error(cip, kDoPerror, "Could not read directory listing data");
                result = kErrLISTFailed;
                cip->errNo = kErrLISTFailed;
                break;
            }
 
            (void) write(outfd, line, strlen(line));
        }
 
        DisposeSReadlineInfo(&lsSrl);
        if (FTPEndDataCmd(cip, 1) < 0) {
            result = kErrLISTFailed;
            cip->errNo = kErrLISTFailed;
        }
    } else if (result == kErrGeneric) {
        result = kErrLISTFailed;
        cip->errNo = kErrLISTFailed;
    }
 
 
#else   /* NO_SIGNALS */
 
    if (result == 0) {
        /* This line sets the buffer pointer so that the first thing
         * BufferGets will do is reset and fill the buffer using
         * real I/O.
         */
        secBufPtr = secondaryBuf + sizeof(secondaryBuf);
        secBufLimit = (char *) 0;
 
        for (;;) {
            if (cip->xferTimeout > 0)
                (void) alarm(cip->xferTimeout);
            nread = BufferGets(line, sizeof(line), cip->dataSocket, secondaryBuf, &secBufPtr, &secBufLimit, sizeof(secondaryBuf));
            if (nread <= 0) {
                if (nread < 0)
                    break;
            } else {
                cip->bytesTransferred += (longest_int) nread;
                (void) STRNCAT(line, "\n");
                (void) write(outfd, line, strlen(line));
            }
        }
        if (cip->xferTimeout > 0)
            (void) alarm(0);
        result = FTPEndDataCmd(cip, 1);
        if (result < 0) {
            result = kErrLISTFailed;
            cip->errNo = kErrLISTFailed;
        }
        result = kNoErr;
        cip->numListings++;
    } else if (result == kErrGeneric) {
        result = kErrLISTFailed;
        cip->errNo = kErrLISTFailed;
    }
#endif  /* NO_SIGNALS */
    return (result);
}   /* FTPList */

◆ FTPListToMemory()

int FTPListToMemory	(	const FTPCIPtr	cip,
		const char *const	pattern,
		const LineListPtr	llines,
		const char *const	lsflags
	)

Definition at line 2819 of file io.c.

{
    return (FTPListToMemory2(cip, pattern, llines, lsflags, 1, (int *) 0));
}   /* FTPListToMemory */

◆ 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.

{
    char secondaryBuf[768];
    char line[512];
    char lsflags1[128];
    const char *command = "NLST";
    const char *scp;
    char *dcp, *lim;
#ifndef NO_SIGNALS
    char *secBufPtr, *secBufLimit;
    volatile FTPSigProc osigpipe;
    volatile FTPCIPtr vcip;
    int sj;
    int nread;
    volatile int result;
#else   /* NO_SIGNALS */
    SReadlineInfo lsSrl;
    int result;
#endif  /* NO_SIGNALS */
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if ((llines == NULL) || (pattern == NULL) || (lsflags == NULL))
        return (kErrBadParameter);
 
    if ((tryMLSD != (int *) 0) && (*tryMLSD != 0) && (cip->hasMLSD == kCommandAvailable)) {
        command = "MLSD";
        if ((lsflags[0] == '-') && (strchr(lsflags, 'd') != NULL) && (cip->hasMLST == kCommandAvailable))
            command = "MLST";
        lsflags1[0] = '\0';
        FTPRequestMlsOptions(cip);
    } else {
        /* Not using MLSD. */
        if (tryMLSD != (int *) 0)
            *tryMLSD = 0;
        if (lsflags[0] == '-') {
            /* See if we should use LIST instead. */
            scp = lsflags + 1;
            dcp = lsflags1;
            lim = lsflags1 + sizeof(lsflags1) - 2;
            for (; *scp != '\0'; scp++) {
                if (*scp == 'l') {
                    /* do not add the 'l' */
                    command = "LIST";
                } else if (dcp < lim) {
                    if (dcp == lsflags1)
                        *dcp++ = '-';
                    *dcp++ = *scp;
                }
            }
            *dcp = '\0';
        } else {
            (void) STRNCPY(lsflags1, lsflags);
        }
    }
 
    InitLineList(llines);
 
    result = FTPStartDataCmd(
        cip,
        kNetReading,
        kTypeAscii,
        (longest_int) 0,
        "%s%s%s%s%s",
        command,
        (lsflags1[0] == '\0') ? "" : " ",
        lsflags1,
        (pattern[0] == '\0') ? "" : " ",
        pattern
    );
 
#ifdef NO_SIGNALS
 
    if (result == 0) {
        if (InitSReadlineInfo(&lsSrl, cip->dataSocket, secondaryBuf, sizeof(secondaryBuf), (int) cip->xferTimeout, 1) < 0) {
            /* Not really fdopen, but close in what we're trying to do. */
            result = kErrFdopenR;
            cip->errNo = kErrFdopenR;
            Error(cip, kDoPerror, "Could not fdopen.\n");
            return (result);
        }
 
        for (;;) {
            result = SReadline(&lsSrl, line, sizeof(line) - 1);
            if (result == kTimeoutErr) {
                /* timeout */
                Error(cip, kDontPerror, "Could not directory listing data -- timed out.\n");
                cip->errNo = kErrDataTimedOut;
                return (cip->errNo);
            } else if (result == 0) {
                /* end of listing -- done */
                cip->numListings++;
                break;
            } else if (result < 0) {
                /* error */
                Error(cip, kDoPerror, "Could not read directory listing data");
                result = kErrLISTFailed;
                cip->errNo = kErrLISTFailed;
                break;
            }
 
            if (line[result - 1] == '\n')
                line[result - 1] = '\0';
 
            if ((blankLines == 0) && (result <= 1))
                continue;
 
            /* Valid directory listing line of output */
            if ((line[0] == '.') && ((line[1] == '\0') || ((line[1] == '.') && ((line[2] == '\0') || (iscntrl(line[2]))))))
                continue;   /* Skip . and .. */
 
            (void) AddLine(llines, line);
        }
 
        DisposeSReadlineInfo(&lsSrl);
        if (FTPEndDataCmd(cip, 1) < 0) {
            result = kErrLISTFailed;
            cip->errNo = kErrLISTFailed;
        }
    } else if (result == kErrGeneric) {
        result = kErrLISTFailed;
        cip->errNo = kErrLISTFailed;
    }
 
 
#else   /* NO_SIGNALS */
    vcip = cip;
    osigpipe = (volatile FTPSigProc) signal(SIGPIPE, BrokenData);
 
    gGotBrokenData = 0;
    gCanBrokenDataJmp = 0;
 
#ifdef HAVE_SIGSETJMP
    sj = sigsetjmp(gBrokenDataJmp, 1);
#else
    sj = setjmp(gBrokenDataJmp);
#endif  /* HAVE_SIGSETJMP */
 
    if (sj != 0) {
        (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
        FTPShutdownHost(vcip);
        vcip->errNo = kErrRemoteHostClosedConnection;
        return(vcip->errNo);
    }
    gCanBrokenDataJmp = 1;
 
    if (result == 0) {
        /* This line sets the buffer pointer so that the first thing
         * BufferGets will do is reset and fill the buffer using
         * real I/O.
         */
        secBufPtr = secondaryBuf + sizeof(secondaryBuf);
        secBufLimit = (char *) 0;
        memset(secondaryBuf, 0, sizeof(secondaryBuf));
 
        for (;;) {
            memset(line, 0, sizeof(line));
            if (cip->xferTimeout > 0)
                (void) alarm(cip->xferTimeout);
            nread = BufferGets(line, sizeof(line), cip->dataSocket, secondaryBuf, &secBufPtr, &secBufLimit, sizeof(secondaryBuf));
            if (nread <= 0) {
                if (nread < 0)
                    break;
                if (blankLines != 0)
                    (void) AddLine(llines, line);
            } else {
                cip->bytesTransferred += (longest_int) nread;
 
                if ((line[0] == '.') && ((line[1] == '\0') || ((line[1] == '.') && ((line[2] == '\0') || (iscntrl(line[2]))))))
                    continue;   /* Skip . and .. */
 
                (void) AddLine(llines, line);
            }
        }
        if (cip->xferTimeout > 0)
            (void) alarm(0);
        result = FTPEndDataCmd(cip, 1);
        if (result < 0) {
            result = kErrLISTFailed;
            cip->errNo = kErrLISTFailed;
        }
        result = kNoErr;
        cip->numListings++;
    } else if (result == kErrGeneric) {
        result = kErrLISTFailed;
        cip->errNo = kErrLISTFailed;
    }
    (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
#endif  /* NO_SIGNALS */
    return (result);
}   /* FTPListToMemory2 */

Referenced by FTPFileExistsNlst(), FTPFileExistsStat(), FTPListToMemory(), FTPRemoteGlob(), FTPRemoteRecursiveFileList(), FTPRemoteRecursiveFileList1(), Ls(), and MlsCmd().

◆ FTPLocalGlob()

int FTPLocalGlob	(	FTPCIPtr	cip,
		LineListPtr	fileList,
		const char *	pattern,
		int	doGlob
	)

Definition at line 1580 of file glob.c.

{
    string pattern2;
    int result;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if (fileList == NULL)
        return (kErrBadParameter);
    InitLineList(fileList);
 
    if ((pattern == NULL) || (pattern[0] == '\0'))
        return (kErrBadParameter);
 
    (void) STRNCPY(pattern2, pattern);  /* Don't nuke the original. */
 
    /* Pre-process for ~'s. */
    ExpandTilde(pattern2, sizeof(pattern2));
    InitLineList(fileList);
    result = kNoErr;
 
    if ((doGlob == 1) && (GLOBCHARSINSTR(pattern2))) {
#if defined(WIN32) || defined(_WINDOWS)
        result = WinLocalGlob(cip, fileList, pattern2);
#else
        result = LazyUnixLocalGlob(cip, fileList, pattern2);
#endif
    } else {
        /* Or, if there were no globbing characters in 'pattern', then
         * the pattern is really just a single pathname.
         */
        (void) AddLine(fileList, pattern2);
    }
 
    return (result);
}   /* FTPLocalGlob */

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.

{
    return (FTPLocalRecursiveFileList2(cip, fileList, files, 0));
}   /* FTPLocalRecursiveFileList */

Referenced by FTPPutFiles3().

◆ FTPLocalRecursiveFileList2()

int FTPLocalRecursiveFileList2	(	FTPCIPtr	cip,
		LineListPtr	fileList,
		FileInfoListPtr	files,
		int	erelative
	)

Definition at line 1276 of file glob.c.

{
    LinePtr filePtr, nextFilePtr;
#if defined(WIN32) || defined(_WINDOWS)
    char fullpath[_MAX_PATH + 1];
    char relpath[_MAX_PATH + 1];
#else
    char fullpath[512];
    char relpath[512];
#endif
    struct Stat st;
    FileInfo fi;
    char *cp;
 
    InitFileInfoList(files);
 
    for (filePtr = fileList->first;
        filePtr != NULL;
        filePtr = nextFilePtr)
    {
        nextFilePtr = filePtr->next;
 
        (void) STRNCPY(fullpath, filePtr->line);    /* initialize fullpath */
        if ((erelative != 0) || (strcmp(filePtr->line, ".") == 0) || (filePtr->line[0] == '\0'))
            (void) STRNCPY(relpath, "");
        else if ((cp = StrRFindLocalPathDelim(filePtr->line)) == NULL)
            (void) STRNCPY(relpath, filePtr->line);
        else
            (void) STRNCPY(relpath, cp + 1);
        if (Lstat(fullpath, &st) < 0) {
            Error(cip, kDoPerror, "could not stat %s.\n", fullpath);
            continue;
        }
 
        if (S_ISDIR(st.st_mode) == 0) {
            fi.relname = StrDup(relpath);
            fi.rname = NULL;
            fi.lname = StrDup(fullpath);
            fi.mdtm = st.st_mtime;
            fi.size = (longest_int) st.st_size;
            fi.rlinkto = NULL;
            fi.plug = NULL;
            fi.type = '-';
            (void) AddFileInfo(files, &fi);
            continue;           /* wasn't a directory */
        }
 
        /* Paths collected must be relative. */
        Traverse(cip, fullpath, &st, relpath, files);
    }
    return (kNoErr);
}   /* FTPLocalRecursiveFileList */

Referenced by FTPLocalRecursiveFileList().

◆ FTPLoginHost()

int FTPLoginHost ( const FTPCIPtr cip )

Definition at line 110 of file open.c.

{
    ResponsePtr rp;
    int result = kErrLoginFailed;
    int anonLogin;
    int sentpass = 0;
    int fwloggedin;
    int firstTime;
    char cwd[512];
 
    if (cip == NULL)
        return (kErrBadParameter);
    if ((cip->firewallType < kFirewallNotInUse) || (cip->firewallType > kFirewallLastType))
        return (kErrBadParameter);
 
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    anonLogin = 0;
    if (cip->user[0] == '\0')
        (void) STRNCPY(cip->user, "anonymous");
    if ((strcmp(cip->user, "anonymous") == 0) || (strcmp(cip->user, "ftp") == 0)) {
        anonLogin = 1;
        /* Try to get the email address if you didn't specify
         * a password when the user is anonymous.
         */
        if (cip->pass[0] == '\0') {
            FTPInitializeAnonPassword(cip->lip);
            (void) STRNCPY(cip->pass, cip->lip->defaultAnonPassword);
        }
    }
 
    rp = InitResponse();
    if (rp == NULL) {
        result = kErrMallocFailed;
        cip->errNo = kErrMallocFailed;
        goto done2;
    }
 
    for (firstTime = 1, fwloggedin = 0; ; ) {
        /* Here's a mini finite-automaton for the login process.
         *
         * Originally, the FTP protocol was designed to be entirely
         * implementable from a FA.  It could be done, but I don't think
         * it's something an interactive process could be the most
         * effective with.
         */
 
        if (firstTime != 0) {
            rp->code = 220;
            firstTime = 0;
        } else if (result < 0) {
            goto done;
        }
 
        switch (rp->code) {
            case 220:   /* Welcome, ready for new user. */
                if ((cip->firewallType == kFirewallNotInUse) || (fwloggedin != 0)) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "USER %s", cip->user);
                } else if (cip->firewallType == kFirewallUserAtSite) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "USER %s@%s", cip->user, cip->host);
                } else if (cip->firewallType == kFirewallUserAtUserPassAtPass) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "USER %s@%s@%s", cip->user, cip->firewallUser, cip->host);
                } else if (cip->firewallType == kFirewallUserAtSiteFwuPassFwp) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "USER %s@%s %s", cip->user, cip->host, cip->firewallUser);
                } else if (cip->firewallType == kFirewallFwuAtSiteFwpUserPass) {
                    /* only reached when !fwloggedin */
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "USER %s@%s", cip->firewallUser, cip->host);
                } else if (cip->firewallType > kFirewallNotInUse) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "USER %s", cip->firewallUser);
                } else {
                    goto unknown;
                }
                break;
 
            case 230:   /* 230 User logged in, proceed. */
            case 231:   /* User name accepted. */
            case 202:   /* Command not implemented, superfluous at this site. */
                if ((cip->firewallType == kFirewallNotInUse) || (fwloggedin != 0))
                    goto okay;
 
                /* Now logged in to the firewall. */
                fwloggedin++;
 
                if (cip->firewallType == kFirewallLoginThenUserAtSite) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "USER %s@%s", cip->user, cip->host);
                } else if (cip->firewallType == kFirewallUserAtUserPassAtPass) {
                    goto okay;
                } else if (cip->firewallType == kFirewallOpenSite) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "OPEN %s", cip->host);
                } else if (cip->firewallType == kFirewallSiteSite) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "SITE %s", cip->host);
                } else if (cip->firewallType == kFirewallFwuAtSiteFwpUserPass) {
                    /* only reached when !fwloggedin */
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "USER %s", cip->user);
                } else /* kFirewallUserAtSite */ {
                    goto okay;
                }
                break;
 
            case 421:   /* 421 Service not available, closing control connection. */
                result = kErrHostDisconnectedDuringLogin;
                goto done;
 
            case 331:   /* 331 User name okay, need password. */
                if ((cip->firewallType == kFirewallNotInUse) || (fwloggedin != 0)) {
                    if ((cip->pass[0] == '\0') && (cip->passphraseProc != NoGetPassphraseProc))
                        (*cip->passphraseProc)(cip, &rp->msg, cip->pass, sizeof(cip->pass));
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "PASS %s", cip->pass);
                } else if (cip->firewallType == kFirewallUserAtSite) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "PASS %s", cip->pass);
                } else if (cip->firewallType == kFirewallUserAtUserPassAtPass) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "PASS %s@%s", cip->pass, cip->firewallPass);
                } else if (cip->firewallType == kFirewallUserAtSiteFwuPassFwp) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "PASS %s", cip->pass);
                } else if (cip->firewallType == kFirewallFwuAtSiteFwpUserPass) {
                    /* only reached when !fwloggedin */
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "PASS %s", cip->firewallPass);
                } else if (cip->firewallType > kFirewallNotInUse) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "PASS %s", cip->firewallPass);
                } else {
                    goto unknown;
                }
                sentpass++;
                break;
 
            case 332:   /* 332 Need account for login. */
            case 532:   /* 532 Need account for storing files. */
                if ((cip->firewallType == kFirewallNotInUse) || (fwloggedin != 0)) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "ACCT %s", cip->acct);
                } else if (cip->firewallType == kFirewallUserAtSiteFwuPassFwp) {
                    ReInitResponse(cip, rp);
                    result = RCmd(cip, rp, "ACCT %s", cip->firewallPass);
                } else {
                    /* ACCT not supported on firewall. */
                    goto unknown;
                }
                break;
 
            case 530:   /* Not logged in. */
                result = (sentpass != 0) ? kErrBadRemoteUserOrPassword : kErrBadRemoteUser;
                goto done;
 
            case 501:   /* Syntax error in parameters or arguments. */
            case 503:   /* Bad sequence of commands. */
            case 550:   /* Can't set guest privileges. */
                goto done;
 
            default:
            unknown:
                if (rp->msg.first == NULL) {
                    Error(cip, kDontPerror, "Lost connection during login.\n");
                } else {
                    Error(cip, kDontPerror, "Unexpected response: %s\n",
                        rp->msg.first->line
                    );
                }
                goto done;
        }
    }
 
okay:
    /* Do the application's connect message callback, if present. */
    if (cip->onLoginMsgProc != 0)
        (*cip->onLoginMsgProc)(cip, rp);
    DoneWithResponse(cip, rp);
    result = 0;
    cip->loggedIn = 1;
 
    /* Make a note of what our root directory is.
     * This is often different from "/" when not
     * logged in anonymously.
     */
    if (cip->startingWorkingDirectory != NULL) {
        free(cip->startingWorkingDirectory);
        cip->startingWorkingDirectory = NULL;
    }
    if ((cip->doNotGetStartingWorkingDirectory == 0) &&
        (FTPGetCWD(cip, cwd, sizeof(cwd)) == kNoErr))
    {
        cip->startingWorkingDirectory = StrDup(cwd);
    }
 
    /* When a new site is opened, ASCII mode is assumed (by protocol). */
    cip->curTransferType = 'A';
    PrintF(cip, "Logged in to %s as %s.\n", cip->host, cip->user);
 
    /* Don't leave cleartext password in memory. */
    if ((anonLogin == 0) && (cip->leavePass == 0))
        (void) memset(cip->pass, '*', strlen(cip->pass));
 
    if (result < 0)
        cip->errNo = result;
    return result;
 
done:
    DoneWithResponse(cip, rp);
 
done2:
    /* Don't leave cleartext password in memory. */
    if ((anonLogin == 0) && (cip->leavePass == 0))
        (void) memset(cip->pass, '*', strlen(cip->pass));
    if (result < 0)
        cip->errNo = result;
    return result;
}   /* FTPLoginHost */

Referenced by FTPOpenHost().

◆ FTPMkdir()

int FTPMkdir	(	const FTPCIPtr	cip,
		const char *const	newDir,
		const int	recurse
	)

Definition at line 641 of file cmds.c.

{
    return (FTPMkdir2(cip, newDir, recurse, NULL));
}   /* FTPMkdir */

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.

{
    int result, result2;
    char *cp, *newTreeStart, *cp2;
    char dir[512];
    char dir2[512];
    char c;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if ((newDir == NULL) || (newDir[0] == '\0')) {
        cip->errNo = kErrInvalidDirParam;
        return (kErrInvalidDirParam);
    }
 
    /* Preserve old working directory. */
    if ((curDir == NULL) || (curDir[0] == '\0')) {
        /* This hack is nice so you can eliminate an
         * unnecessary "PWD" command on the server,
         * since if you already knew what directory
         * you're in.  We want to minimize the number
         * of client-server exchanges when feasible.
         */
        (void) FTPGetCWD(cip, cip->buf, cip->bufSize);
    }
 
    result = FTPChdir(cip, newDir);
    if (result == kNoErr) {
        /* Directory already exists -- but we
         * must now change back to where we were.
         */
        result2 = FTPChdir(cip, ((curDir == NULL) || (curDir[0] == '\0')) ? cip->buf : curDir);
        if (result2 < 0) {
            result = kErrCannotGoToPrevDir;
            cip->errNo = kErrCannotGoToPrevDir;
            return (result);
        }
 
        /* Don't need to create it. */
        return (kNoErr);
    }
 
    if (recurse == kRecursiveNo) {
        result = FTPCmd(cip, "MKD %s", newDir);
        if (result > 0) {
            if (result != 2) {
                Error(cip, kDontPerror, "MKD %s failed; [%s]\n", newDir, cip->lastFTPCmdResultStr);
                result = kErrMKDFailed;
                cip->errNo = kErrMKDFailed;
                return (result);
            } else {
                result = kNoErr;
            }
        }
    } else {
        (void) STRNCPY(dir, newDir);
 
        /* Strip trailing slashes. */
        cp = dir + strlen(dir) - 1;
        for (;;) {
            if (cp <= dir) {
                if ((newDir == NULL) || (newDir[0] == '\0')) {
                    cip->errNo = kErrInvalidDirParam;
                    result = kErrInvalidDirParam;
                    return (result);
                }
            }
            if ((*cp != '/') && (*cp != '\\')) {
                cp[1] = '\0';
                break;
            }
            --cp;
        }
        (void) STRNCPY(dir2, dir);
 
        if ((strrchr(dir, '/') == dir) || (strrchr(dir, '\\') == dir)) {
            /* Special case "mkdir /subdir" */
            result = FTPCmd(cip, "MKD %s", dir);
            if (result < 0) {
                return (result);
            }
            if (result != 2) {
                Error(cip, kDontPerror, "MKD %s failed; [%s]\n", dir, cip->lastFTPCmdResultStr);
                result = kErrMKDFailed;
                cip->errNo = kErrMKDFailed;
                return (result);
            }
            /* Haven't chdir'ed, don't need to goto goback. */
            return (kNoErr);
        }
 
        for (;;) {
            cp = strrchr(dir, '/');
            if (cp == NULL)
                cp = strrchr(dir, '\\');
            if (cp == NULL) {
                cp = dir + strlen(dir) - 1;
                if (dir[0] == '\0') {
                    result = kErrMKDFailed;
                    cip->errNo = kErrMKDFailed;
                    return (result);
                }
                /* Note: below we will refer to cp + 1
                 * which is why we set cp to point to
                 * the byte before the array begins!
                 */
                cp = dir - 1;
                break;
            }
            if (cp == dir) {
                result = kErrMKDFailed;
                cip->errNo = kErrMKDFailed;
                return (result);
            }
            *cp = '\0';
            result = FTPChdir(cip, dir);
            if (result == 0) {
                break;  /* Found a valid parent dir. */
                /* from this point, we need to preserve old dir. */
            }
        }
 
        newTreeStart = dir2 + ((cp + 1) - dir);
        for (cp = newTreeStart; ; ) {
            cp2 = cp;
            cp = strchr(cp2, '/');
            c = '/';
            if (cp == NULL)
                cp = strchr(cp2, '\\');
            if (cp != NULL) {
                c = *cp;
                *cp = '\0';
                if (cp[1] == '\0') {
                    /* Done, if they did "mkdir /tmp/dir/" */
                    break;
                }
            }
            result = FTPCmd(cip, "MKD %s", newTreeStart);
            if (result < 0) {
                return (result);
            }
            if (result != 2) {
                Error(cip, kDontPerror, "Cwd=%s; MKD %s failed; [%s]\n", cip->buf, newTreeStart, cip->lastFTPCmdResultStr);
                result = kErrMKDFailed;
                cip->errNo = kErrMKDFailed;
                goto goback;
            }
            if (cp == NULL)
                break;  /* No more to make, done. */
            *cp++ = c;
        }
        result = kNoErr;
 
goback:
        result2 = FTPChdir(cip, ((curDir == NULL) || (curDir[0] == '\0')) ? cip->buf : curDir);
        if ((result == 0) && (result2 < 0)) {
            result = kErrCannotGoToPrevDir;
            cip->errNo = kErrCannotGoToPrevDir;
        }
    }
    return (result);
}   /* FTPMkdir2 */

Referenced by FTPMkdir().

◆ FTPMListOneFile()

int FTPMListOneFile	(	const FTPCIPtr	cip,
		const char *const	file,
		const MLstItemPtr	mlip
	)

Definition at line 947 of file cmds.c.

{
    int result;
    ResponsePtr rp;
 
    /* We do a special check for older versions of NcFTPd which
     * are based off of an incompatible previous version of IETF
     * extensions.
     *
     * Roxen also seems to be way outdated, where MLST was on the
     * data connection among other things.
     *
     */
    if (
        (cip->hasMLST == kCommandNotAvailable) ||
        ((cip->serverType == kServerTypeNcFTPd) && (cip->ietfCompatLevel < 19981201)) ||
        (cip->serverType == kServerTypeRoxen)
    ) {
        cip->errNo = kErrMLSTNotAvailable;
        return (cip->errNo);
    }
 
    rp = InitResponse();
    if (rp == NULL) {
        result = cip->errNo = kErrMallocFailed;
        Error(cip, kDontPerror, "Malloc failed.\n");
    } else {
        result = RCmd(cip, rp, "MLST %s", file);
        if (
            (result == 2) &&
            (rp->msg.first->line != NULL) &&
            (rp->msg.first->next != NULL) &&
            (rp->msg.first->next->line != NULL)
        ) {
            result = UnMlsT(rp->msg.first->next->line, mlip);
            if (result < 0) {
                cip->errNo = result = kErrInvalidMLSTResponse;
            }
        } else if (UNIMPLEMENTED_CMD(rp->code)) {
            cip->hasMLST = kCommandNotAvailable;
            cip->errNo = kErrMLSTNotAvailable;
            result = kErrMLSTNotAvailable;
        } else {
            cip->errNo = kErrMLSTFailed;
            result = kErrMLSTFailed;
        }
        DoneWithResponse(cip, rp);
    }
 
    return (result);
}   /* FTPMListOneFile */

Referenced by FTPFileExists2(), FTPFileSizeAndModificationTime(), and FTPFileType().

◆ FTPOpenHost()

int FTPOpenHost ( const FTPCIPtr cip )

Definition at line 818 of file open.c.

{
    int result;
    time_t t0, t1;
    int elapsed;
    int dials;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if (cip->host[0] == '\0') {
        cip->errNo = kErrBadParameter;
        return (kErrBadParameter);
    }
 
    for (   result = kErrConnectMiscErr, dials = 0;
        cip->maxDials < 0 || dials < cip->maxDials;
        dials++)
    {
        /* Allocate (or if the host was closed, reallocate)
         * the transfer data buffer.
         */
        result = FTPAllocateHost(cip);
        if (result < 0)
            return (result);
 
        if (dials > 0)
            PrintF(cip, "Retry Number: %d\n", dials);
        if (cip->redialStatusProc != 0)
            (*cip->redialStatusProc)(cip, kRedialStatusDialing, dials);
        (void) time(&t0);
        result = OpenControlConnection(cip, cip->host, cip->port);
        (void) time(&t1);
        if (result == kNoErr) {
            /* We were hooked up successfully. */
            PrintF(cip, "Connected to %s.\n", cip->host);
 
            result = FTPLoginHost(cip);
            if (result == kNoErr) {
                (void) FTPQueryFeatures(cip);
                break;
            }
 
            /* Close and try again. */
            (void) FTPCloseHost(cip);
 
            /* Originally we also stopped retyring if
             * we got kErrBadRemoteUser and non-anonymous,
             * but some FTP servers apparently do their
             * max user check after the username is sent.
             */
            if (result == kErrBadRemoteUserOrPassword /* || (result == kErrBadRemoteUser) */) {
                if (strcmp(cip->user, "anonymous") != 0) {
                    /* Non-anonymous login was denied, and
                     * retrying is not going to help.
                     */
                    break;
                }
            }
        } else if ((result != kErrConnectRetryableErr) && (result != kErrConnectRefused) && (result != kErrRemoteHostClosedConnection)) {
            /* Irrecoverable error, so don't bother redialing.
             * The error message should have already been printed
             * from OpenControlConnection().
             */
            PrintF(cip, "Cannot recover from miscellaneous open error %d.\n", result);
            return result;
        }
 
        /* Retryable error, wait and then redial. */
        if (cip->redialDelay > 0) {
            /* But don't sleep if this is the last loop. */
            if ((cip->maxDials < 0) || (dials < (cip->maxDials - 1))) {
                elapsed = (int) (t1 - t0);
                if (elapsed < cip->redialDelay) {
                    PrintF(cip, "Sleeping %u seconds.\n",
                        (unsigned) cip->redialDelay - elapsed);
                    if (cip->redialStatusProc != 0)
                        (*cip->redialStatusProc)(cip, kRedialStatusSleeping, cip->redialDelay - elapsed);
                    (void) sleep((unsigned) cip->redialDelay - elapsed);
                }
            }
        }
    }
    return (result);
}   /* FTPOpenHost */

Referenced by DoOpen().

◆ FTPOpenHostNoLogin()

int FTPOpenHostNoLogin ( const FTPCIPtr cip )

Definition at line 910 of file open.c.

{
    int result;
    time_t t0, t1;
    int elapsed;
    int dials;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if (cip->host[0] == '\0') {
        cip->errNo = kErrBadParameter;
        return (kErrBadParameter);
    }
 
    for (   result = kErrConnectMiscErr, dials = 0;
        cip->maxDials < 0 || dials < cip->maxDials;
        dials++)
    {
 
        /* Allocate (or if the host was closed, reallocate)
         * the transfer data buffer.
         */
        result = FTPAllocateHost(cip);
        if (result < 0)
            return (result);
 
        if (dials > 0)
            PrintF(cip, "Retry Number: %d\n", dials);
        if (cip->redialStatusProc != 0)
            (*cip->redialStatusProc)(cip, kRedialStatusDialing, dials);
        (void) time(&t0);
        result = OpenControlConnection(cip, cip->host, cip->port);
        (void) time(&t1);
        if (result == kNoErr) {
            /* We were hooked up successfully. */
            PrintF(cip, "Connected to %s.\n", cip->host);
 
            /* Not logging in... */
            if (result == kNoErr)
                break;
        } else if ((result != kErrConnectRetryableErr) && (result != kErrConnectRefused) && (result != kErrRemoteHostClosedConnection)) {
            /* Irrecoverable error, so don't bother redialing.
             * The error message should have already been printed
             * from OpenControlConnection().
             */
            PrintF(cip, "Cannot recover from miscellaneous open error %d.\n", result);
            return result;
        }
 
        /* Retryable error, wait and then redial. */
        if (cip->redialDelay > 0) {
            /* But don't sleep if this is the last loop. */
            if ((cip->maxDials < 0) || (dials < (cip->maxDials - 1))) {
                elapsed = (int) (t1 - t0);
                if (elapsed < cip->redialDelay) {
                    PrintF(cip, "Sleeping %u seconds.\n",
                        (unsigned) cip->redialDelay - elapsed);
                    if (cip->redialStatusProc != 0)
                        (*cip->redialStatusProc)(cip, kRedialStatusSleeping, cip->redialDelay - elapsed);
                    (void) sleep((unsigned) cip->redialDelay - elapsed);
                }
            }
        }
    }
    return (result);
}   /* 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.

{
    if (err != kNoErr) {
        if (err == eerr) {
            if ((s2 == NULL) || (s2[0] == '\0')) {
                if ((s1 == NULL) || (s1[0] == '\0')) {
                    (void) fprintf(stderr, "server said: %s\n", cip->lastFTPCmdResultStr);
                } else {
                    (void) fprintf(stderr, "%s: server said: %s\n", s1, cip->lastFTPCmdResultStr);
                }
            } else if ((s1 == NULL) || (s1[0] == '\0')) {
                (void) fprintf(stderr, "%s: server said: %s\n", s2, cip->lastFTPCmdResultStr);
            } else {
                (void) fprintf(stderr, "%s %s: server said: %s\n", s1, s2, cip->lastFTPCmdResultStr);
            }
        } else {
            if ((s2 == NULL) || (s2[0] == '\0')) {
                if ((s1 == NULL) || (s1[0] == '\0')) {
                    (void) fprintf(stderr, "%s.\n", FTPStrError(cip->errNo));
                } else {
                    (void) fprintf(stderr, "%s: %s.\n", s1, FTPStrError(cip->errNo));
                }
            } else if ((s1 == NULL) || (s1[0] == '\0')) {
                (void) fprintf(stderr, "%s: %s.\n", s2, FTPStrError(cip->errNo));
            } else {
                (void) fprintf(stderr, "%s %s: %s.\n", s1, s2, FTPStrError(cip->errNo));
            }
        }
    }
}   /* FTPPerror */

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.

{
    return (FTPPutFiles3(cip, pattern, dstdir, recurse, doGlob, kTypeBinary, 0, NULL, NULL, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
}   /* FTPPutFiles */

◆ 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.

{
    return (FTPPutFiles3(cip, pattern, dstdir, recurse, doGlob, xtype, appendflag, tmppfx, tmpsfx, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
}   /* 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.

{
    return (FTPPutFiles3(cip, pattern, dstdir, recurse, doGlob, kTypeAscii, 0, NULL, NULL, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
}   /* FTPPutFilesAscii */

◆ FTPPutOneFile()

int FTPPutOneFile	(	const FTPCIPtr	cip,
		const char *const	file,
		const char *const	dstfile
	)

Definition at line 2766 of file io.c.

{
    return (FTPPutOneFile3(cip, file, dstfile, kTypeBinary, -1, 0, NULL, NULL, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
}   /* FTPPutOneFile */

◆ 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.

{
    return (FTPPutOneFile3(cip, file, dstfile, xtype, fdtouse, appendflag, tmppfx, tmpsfx, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
}   /* 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()

int FTPPutOneFileAscii	(	const FTPCIPtr	cip,
		const char *const	file,
		const char *const	dstfile
	)

Definition at line 2802 of file io.c.

{
    return (FTPPutOneFile3(cip, file, dstfile, kTypeAscii, -1, 0, NULL, NULL, kResumeNo, kDeleteNo, NoConfirmResumeUploadProc, 0));
}   /* FTPPutOneFileAscii */

◆ FTPQueryFeatures()

int FTPQueryFeatures ( const FTPCIPtr )

Definition at line 380 of file open.c.

{
    ResponsePtr rp;
    int result;
    LinePtr lp;
    char *cp, *p;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if (cip->serverType == kServerTypeNetWareFTP) {
        /* NetWare 5.00 server freaks out when
         * you give it a command it doesn't
         * recognize, so cheat here and return.
         */
        cip->hasPASV = kCommandAvailable;
        cip->hasSIZE = kCommandNotAvailable;
        cip->hasMDTM = kCommandNotAvailable;
        cip->hasREST = kCommandNotAvailable;
        cip->NLSTfileParamWorks = kCommandAvailable;
        cip->hasUTIME = kCommandNotAvailable;
        cip->hasCLNT = kCommandNotAvailable;
        cip->hasMLST = kCommandNotAvailable;
        cip->hasMLSD = kCommandNotAvailable;
        return (kNoErr);
    }
 
    rp = InitResponse();
    if (rp == NULL) {
        cip->errNo = kErrMallocFailed;
        result = cip->errNo;
    } else {
        rp->printMode = (kResponseNoPrint|kResponseNoSave);
        result = RCmd(cip, rp, "FEAT");
        if (result < kNoErr) {
            DoneWithResponse(cip, rp);
            return (result);
        } else if (result != 2) {
            /* We cheat here and pre-populate some
             * fields when the server is wu-ftpd.
             * This server is very common and we
             * know it has always had these.
             */
             if (cip->serverType == kServerTypeWuFTPd) {
                cip->hasPASV = kCommandAvailable;
                cip->hasSIZE = kCommandAvailable;
                cip->hasMDTM = kCommandAvailable;
                cip->hasREST = kCommandAvailable;
                cip->NLSTfileParamWorks = kCommandAvailable;
            } else if (cip->serverType == kServerTypeNcFTPd) {
                cip->hasPASV = kCommandAvailable;
                cip->hasSIZE = kCommandAvailable;
                cip->hasMDTM = kCommandAvailable;
                cip->hasREST = kCommandAvailable;
                cip->NLSTfileParamWorks = kCommandAvailable;
            }
 
            /* Newer commands are only shown in FEAT,
             * so we don't have to do the "try it,
             * then save that it didn't work" thing.
             */
            cip->hasMLST = kCommandNotAvailable;
            cip->hasMLSD = kCommandNotAvailable;
        } else {
            cip->hasFEAT = kCommandAvailable;
 
            for (lp = rp->msg.first; lp != NULL; lp = lp->next) {
                /* If first character was not a space it is
                 * either:
                 *
                 * (a) The header line in the response;
                 * (b) The trailer line in the response;
                 * (c) A protocol violation.
                 */
                cp = lp->line;
                if (*cp++ != ' ')
                    continue;
                if (ISTRNCMP(cp, "PASV", 4) == 0) {
                    cip->hasPASV = kCommandAvailable;
                } else if (ISTRNCMP(cp, "SIZE", 4) == 0) {
                    cip->hasSIZE = kCommandAvailable;
                } else if (ISTRNCMP(cp, "MDTM", 4) == 0) {
                    cip->hasMDTM = kCommandAvailable;
                } else if (ISTRNCMP(cp, "REST", 4) == 0) {
                    cip->hasREST = kCommandAvailable;
                } else if (ISTRNCMP(cp, "UTIME", 5) == 0) {
                    cip->hasUTIME = kCommandAvailable;
                } else if (ISTRNCMP(cp, "MLST", 4) == 0) {
                    cip->hasMLST = kCommandAvailable;
                    cip->hasMLSD = kCommandAvailable;
                    FTPExamineMlstFeatures(cip, cp + 5);
                } else if (ISTRNCMP(cp, "CLNT", 4) == 0) {
                    cip->hasCLNT = kCommandAvailable;
                } else if (ISTRNCMP(cp, "Compliance Level: ", 18) == 0) {
                    /* Probably only NcFTPd will ever implement this.
                     * But we use it internally to differentiate
                     * between different NcFTPd implementations of
                     * IETF extensions.
                     */
                    cip->ietfCompatLevel = atoi(cp + 18);
                }
            }
        }
 
        ReInitResponse(cip, rp);
        result = RCmd(cip, rp, "HELP SITE");
        if (result == 2) {
            for (lp = rp->msg.first; lp != NULL; lp = lp->next) {
                cp = lp->line;
                if (strstr(cp, "RETRBUFSIZE") != NULL)
                    cip->hasRETRBUFSIZE = kCommandAvailable;
                if (strstr(cp, "RBUFSZ") != NULL)
                    cip->hasRBUFSZ = kCommandAvailable;
                /* See if RBUFSIZ matches (but not STORBUFSIZE) */
                if (
                    ((p = strstr(cp, "RBUFSIZ")) != NULL) &&
                    (
                        (p == cp) ||
                        ((p > cp) && (!isupper(p[-1])))
                    )
                )
                    cip->hasRBUFSIZ = kCommandAvailable;
                if (strstr(cp, "STORBUFSIZE") != NULL)
                    cip->hasSTORBUFSIZE = kCommandAvailable;
                if (strstr(cp, "SBUFSIZ") != NULL)
                    cip->hasSBUFSIZ = kCommandAvailable;
                if (strstr(cp, "SBUFSZ") != NULL)
                    cip->hasSBUFSZ = kCommandAvailable;
                if (strstr(cp, "BUFSIZE") != NULL)
                    cip->hasBUFSIZE = kCommandAvailable;
            }
        }
        DoneWithResponse(cip, rp);
    }
 
    return (kNoErr);
}   /* FTPQueryFeatures */

Referenced by FTPOpenHost().

◆ FTPRebuildConnectionInfo()

int FTPRebuildConnectionInfo	(	const FTPLIPtr	lip,
		const FTPCIPtr	cip
	)

Definition at line 1041 of file open.c.

{
    char *buf;
 
    cip->lip = lip;
    cip->debugLog = NULL;
    cip->errLog = NULL;
    cip->debugLogProc = NULL;
    cip->errLogProc = NULL;
    cip->buf = NULL;
    cip->cin = NULL;
    cip->cout = NULL;
    cip->errNo = 0;
    cip->progress = NULL;
    cip->rname = NULL;
    cip->lname = NULL;
    cip->onConnectMsgProc = NULL;
    cip->redialStatusProc = NULL;
    cip->printResponseProc = NULL;
    cip->onLoginMsgProc = NULL;
    cip->passphraseProc = NULL;
    cip->startingWorkingDirectory = NULL;
    cip->asciiFilenameExtensions = NULL;
 
    (void) memset(&cip->lastFTPCmdResultLL, 0, sizeof(LineList));
 
    /* Allocate a new buffer. */
    buf = (char *) calloc((size_t) 1, cip->bufSize);
    if (buf == NULL) {
        cip->errNo = kErrMallocFailed;
        return (kErrMallocFailed);
    }
    cip->buf = buf;
 
    /* Reattach the FILE pointers for use with the Std I/O library
     * routines.
     */
    if ((cip->cin = _fdopen(cip->ctrlSocketR, "r")) == NULL) {
        cip->errNo = kErrFdopenR;
        cip->ctrlSocketR = kClosedFileDescriptor;
        cip->ctrlSocketW = kClosedFileDescriptor;
        return (kErrFdopenR);
    }
 
    if ((cip->cout = _fdopen(cip->ctrlSocketW, "w")) == NULL) {
        CloseFile(&cip->cin);
        cip->errNo = kErrFdopenW;
        cip->ctrlSocketR = kClosedFileDescriptor;
        cip->ctrlSocketW = kClosedFileDescriptor;
        return (kErrFdopenW);
    }
 
#if USE_SIO
    if (InitSReadlineInfo(&cip->ctrlSrl, cip->ctrlSocketR, cip->srlBuf, sizeof(cip->srlBuf), (int) cip->ctrlTimeout, 1) < 0) {
        cip->errNo = kErrFdopenW;
        CloseFile(&cip->cin);
        cip->errNo = kErrFdopenW;
        cip->ctrlSocketR = kClosedFileDescriptor;
        cip->ctrlSocketW = kClosedFileDescriptor;
        return (kErrFdopenW);
    }
#endif
    return (kNoErr);
}   /* FTPRebuildConnectionInfo */

◆ FTPRemoteGlob()

int FTPRemoteGlob	(	FTPCIPtr	cip,
		LineListPtr	fileList,
		const char *	pattern,
		int	doGlob
	)

Definition at line 1341 of file glob.c.

{
    char *cp;
    const char *lsflags;
    LinePtr lp;
    int result;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if (fileList == NULL)
        return (kErrBadParameter);
    InitLineList(fileList);
 
    if ((pattern == NULL) || (pattern[0] == '\0'))
        return (kErrBadParameter);
 
    /* Note that we do attempt to use glob characters even if the remote
     * host isn't UNIX.  Most non-UNIX remote FTP servers look for UNIX
     * style wildcards.
     */
    if ((doGlob == 1) && (GLOBCHARSINSTR(pattern))) {
        /* Use NLST, which lists files one per line. */
        lsflags = "";
 
        /* Optimize for "NLST *" case which is same as "NLST". */
        if (strcmp(pattern, "*") == 0) {
            pattern = "";
        } else if (strcmp(pattern, "**") == 0) {
            /* Hack; Lets you try "NLST -a" if you're daring. */
            pattern = "";
            lsflags = "-a";
        }
 
        if ((result = FTPListToMemory2(cip, pattern, fileList, lsflags, 0, (int *) 0)) < 0) {
            if (*lsflags == '\0')
                return (result);
            /* Try again, without "-a" */
            lsflags = "";
            if ((result = FTPListToMemory2(cip, pattern, fileList, lsflags, 0, (int *) 0)) < 0) {
                return (result);
            }
        }
        if (fileList->first == NULL) {
            cip->errNo = kErrGlobNoMatch;
            return (kErrGlobNoMatch);
        }
        if (fileList->first == fileList->last) {
#define glberr(a) (ISTRNEQ(cp, a, strlen(a)))
            /* If we have only one item in the list, see if it really was
             * an error message we would recognize.
             */
            cp = strchr(fileList->first->line, ':');
            if (cp != NULL) {
                if (glberr(": No such file or directory")) {
                    (void) RemoveLine(fileList, fileList->first);
                    cip->errNo = kErrGlobFailed;
                    return (kErrGlobFailed);
                } else if (glberr(": No match")) {
                    cip->errNo = kErrGlobNoMatch;
                    return (kErrGlobNoMatch);
                }
            }
        }
        RemoteGlobCollapse(pattern, fileList);
        for (lp=fileList->first; lp != NULL; lp = lp->next)
            PrintF(cip, "  Rglob [%s]\n", lp->line);
    } else {
        /* Or, if there were no globbing characters in 'pattern', then the
         * pattern is really just a filename.  So for this case the
         * file list is really just a single file.
         */
        fileList->first = fileList->last = NULL;
        (void) AddLine(fileList, pattern);
    }
    return (kNoErr);
}   /* FTPRemoteGlob */

Referenced by ChdirCmd(), FTPChmod(), FTPDelete(), FTPFtwL2(), FTPGetFiles3(), FTPRmdir(), FTPRmdirRecursiveL2(), RGlobCmd(), and SpoolGetCmd().

◆ FTPRemoteHelp()

int FTPRemoteHelp	(	const	FTPCIPtr,
		const char * const	pattern,
		const	LineListPtr
	)

Definition at line 739 of file cmds.c.

{
    int result;
    ResponsePtr rp;
 
    if ((cip == NULL) || (llp == NULL))
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    InitLineList(llp);
    rp = InitResponse();
    if (rp == NULL) {
        result = kErrMallocFailed;
        cip->errNo = kErrMallocFailed;
        Error(cip, kDontPerror, "Malloc failed.\n");
    } else {
        if ((pattern == NULL) || (*pattern == '\0'))
            result = RCmd(cip, rp, "HELP");
        else
            result = RCmd(cip, rp, "HELP %s", pattern);
        if (result < 0) {
            DoneWithResponse(cip, rp);
            return (result);
        } else if (result == 2) {
            if (CopyLineList(llp, &rp->msg) < 0) {
                result = kErrMallocFailed;
                cip->errNo = kErrMallocFailed;
                Error(cip, kDontPerror, "Malloc failed.\n");
            } else {
                result = kNoErr;
            }
        } else {
            cip->errNo = kErrHELPFailed;
            result = kErrHELPFailed;
        }
        DoneWithResponse(cip, rp);
    }
    return (result);
}   /* FTPRemoteHelp */

Referenced by RmtHelpCmd().

◆ FTPRemoteRecursiveFileList()

int FTPRemoteRecursiveFileList	(	FTPCIPtr	cip,
		LineListPtr	fileList,
		FileInfoListPtr	files
	)

Definition at line 1032 of file glob.c.

{
    LinePtr filePtr, nextFilePtr;
    LineList dirContents;
    FileInfoList fil;
    char cwd[512];
    int result;
    char *rdir;
 
    if ((result = FTPGetCWD(cip, cwd, sizeof(cwd))) < 0)
        return (result);
 
    InitFileInfoList(files);
 
    for (filePtr = fileList->first;
        filePtr != NULL;
        filePtr = nextFilePtr)
    {
        nextFilePtr = filePtr->next;
 
        rdir = filePtr->line;
        if (rdir == NULL)
            continue;
 
        if (FTPChdir(cip, rdir) < 0) {
            /* Probably not a directory.
             * Just add it as a plain file
             * to the list.
             */
            (void) ConcatFileToFileInfoList(files, rdir);
            continue;
        }
 
        /* Paths collected must be relative. */
        if ((result = FTPListToMemory2(cip, "", &dirContents, "-lRa", 1, (int *) 0)) < 0) {
            goto goback;
        }
 
        (void) UnLslR(&fil, &dirContents, cip->serverType);
        DisposeLineListContents(&dirContents);
        (void) ComputeRNames(&fil, rdir, 1, 1);
        (void) ConcatFileInfoList(files, &fil);
        DisposeFileInfoListContents(&fil);
 
goback:
        if ((result = FTPChdir(cip, cwd)) < 0) {
            return (result);
        }
    }
    return (kNoErr);
}   /* FTPRemoteRecursiveFileList */

◆ FTPRemoteRecursiveFileList1()

int FTPRemoteRecursiveFileList1	(	FTPCIPtr	cip,
		char * const	rdir,
		FileInfoListPtr	files
	)

Definition at line 983 of file glob.c.

{
    LineList dirContents;
    FileInfoList fil;
    char cwd[512];
    int result;
 
    if ((result = FTPGetCWD(cip, cwd, sizeof(cwd))) < 0)
        return (result);
 
    InitFileInfoList(files);
 
    if (rdir == NULL)
        return (-1);
 
    if (FTPChdir(cip, rdir) < 0) {
        /* Probably not a directory.
         * Just add it as a plain file
         * to the list.
         */
        (void) ConcatFileToFileInfoList(files, rdir);
        return (kNoErr);
    }
 
    /* Paths collected must be relative. */
    if ((result = FTPListToMemory2(cip, "", &dirContents, "-lRa", 1, (int *) 0)) < 0) {
        if ((result = FTPChdir(cip, cwd)) < 0) {
            return (result);
        }
    }
 
    (void) UnLslR(&fil, &dirContents, cip->serverType);
    DisposeLineListContents(&dirContents);
    /* Could sort it to breadth-first here. */
    /* (void) SortRecursiveFileList(&fil); */
    (void) ComputeRNames(&fil, rdir, 1, 1);
    (void) ConcatFileInfoList(files, &fil);
    DisposeFileInfoListContents(&fil);
 
    if ((result = FTPChdir(cip, cwd)) < 0) {
        return (result);
    }
    return (kNoErr);
}   /* FTPRemoteRecursiveFileList1 */

Referenced by FTPGetFiles3().

◆ FTPRename()

int FTPRename	(	const FTPCIPtr	cip,
		const char *const	oldname,
		const char *const	newname
	)

Definition at line 703 of file cmds.c.

{
    int result;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
    if ((oldname == NULL) || (oldname[0] == '\0'))
        return (kErrBadParameter);
    if ((newname == NULL) || (oldname[0] == '\0'))
        return (kErrBadParameter);
 
 
    result = FTPCmd(cip, "RNFR %s", oldname);
    if (result < 0)
        return (result);
    if (result != 3) {
        cip->errNo = kErrRenameFailed;
        return (cip->errNo);
    }
 
    result = FTPCmd(cip, "RNTO %s", newname);
    if (result < 0)
        return (result);
    if (result != 2) {
        cip->errNo = kErrRenameFailed;
        return (cip->errNo);
    }
    return (kNoErr);
}   /* FTPRename */

Referenced by FTPPutOneF(), and RenameCmd().

◆ FTPRmdir()

int FTPRmdir	(	const FTPCIPtr	cip,
		const char *const	pattern,
		const int	recurse,
		const int	doGlob
	)

Definition at line 784 of file cmds.c.

{
    LineList fileList;
    LinePtr filePtr;
    char *file;
    int onceResult, batchResult;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    batchResult = FTPRemoteGlob(cip, &fileList, pattern, doGlob);
    if (batchResult != kNoErr)
        return (batchResult);
 
    for (batchResult = kNoErr, filePtr = fileList.first;
        filePtr != NULL;
        filePtr = filePtr->next)
    {
        file = filePtr->line;
        if (file == NULL) {
            batchResult = kErrBadLineList;
            cip->errNo = kErrBadLineList;
            break;
        }
        onceResult = FTPCmd(cip, "RMD %s", file);
        if (onceResult < 0) {
            batchResult = onceResult;
            break;
        }
        if (onceResult != 2) {
            if (recurse == kRecursiveYes) {
                onceResult = FTPRmdirRecursive(cip, file);
                if (onceResult < 0) {
                    batchResult = kErrRMDFailed;
                    cip->errNo = kErrRMDFailed;
                }
            } else {
                batchResult = kErrRMDFailed;
                cip->errNo = kErrRMDFailed;
            }
        }
    }
    DisposeLineListContents(&fileList);
    return (batchResult);
}   /* FTPRmdir */

Referenced by FTPRmdirRecursive(), FTPRmdirRecursiveL2(), and RmdirCmd().

◆ FTPSetTransferType()

int FTPSetTransferType	(	const	FTPCIPtr,
		int	type
	)

Definition at line 836 of file cmds.c.

{
    int result;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if (cip->curTransferType != type) {
        switch (type) {
            case kTypeAscii:
            case kTypeBinary:
            case kTypeEbcdic:
                break;
            case 'i':
            case 'b':
            case 'B':
                type = kTypeBinary;
                break;
            case 'e':
                type = kTypeEbcdic;
                break;
            case 'a':
                type = kTypeAscii;
                break;
            default:
                /* Yeah, we don't support Tenex.  Who cares? */
                Error(cip, kDontPerror, "Bad transfer type [%c].\n", type);
                cip->errNo = kErrBadTransferType;
                return (kErrBadTransferType);
        }
        result = FTPCmd(cip, "TYPE %c", type);
        if (result != 2) {
            result = kErrTYPEFailed;
            cip->errNo = kErrTYPEFailed;
            return (result);
        }
        cip->curTransferType = type;
    }
    return (kNoErr);
}   /* FTPSetTransferType */

Referenced by FTPFileSize(), FTPFileSizeAndModificationTime(), FTPGetOneF(), FTPPutOneF(), FTPStartDataCmd(), and TypeCmd().

◆ FTPShutdownHost()

void FTPShutdownHost ( const FTPCIPtr cip )

Definition at line 564 of file open.c.

{
#ifdef SIGPIPE
    FTPSigProc osigpipe;
#endif
 
    if (cip == NULL)
        return;
    if (strcmp(cip->magic, kLibraryMagic))
        return;
 
#ifdef SIGPIPE
    osigpipe = signal(SIGPIPE, (FTPSigProc) SIG_IGN);
#endif
 
    /* Linger could cause close to block, so unset it. */
    if (cip->dataSocket != kClosedFileDescriptor)
        (void) SetLinger(cip, cip->dataSocket, 0);
    CloseDataConnection(cip);   /* Shouldn't be open normally. */
 
    /* Linger should already be turned off for this. */
    CloseControlConnection(cip);
 
    FTPDeallocateHost(cip);
 
#ifdef SIGPIPE
    (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
#endif
}   /* 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.

{
    va_list ap;
    int result;
    int respCode;
    ResponsePtr rp;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    result = FTPSetTransferType(cip, type);
    if (result < 0)
        return (result);
 
    /* Re-set the cancellation flag. */
    cip->cancelXfer = 0;
 
    /* To transfer data, we do these things in order as specifed by
     * the RFC.
     *
     * First, we tell the other side to set up a data line.  This
     * is done below by calling OpenDataConnection(), which sets up
     * the socket.  When we do that, the other side detects a connection
     * attempt, so it knows we're there.  Then tell the other side
     * (by using listen()) that we're willing to receive a connection
     * going to our side.
     */
 
    if ((result = OpenDataConnection(cip, cip->dataPortMode)) < 0)
        goto done;
 
    /* If asked, attempt to start at a later position in the remote file. */
    if (startPoint != (longest_int) 0) {
        if ((startPoint == kSizeUnknown) || ((result = SetStartOffset(cip, startPoint)) != 0))
            startPoint = (longest_int) 0;
    }
    cip->startPoint = startPoint;
 
    /* Now we tell the server what we want to do.  This sends the
     * the type of transfer we want (RETR, STOR, LIST, etc) and the
     * parameters for that (files to send, directories to list, etc).
     */
    va_start(ap, cmdspec);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(cip->ctrlTimeout);
#endif  /* NO_SIGNALS */
    result = SendCommand(cip, cmdspec, ap);
    va_end(ap);
    if (result < 0) {
#ifndef NO_SIGNALS
        if (cip->ctrlTimeout > 0)
            (void) alarm(0);
#endif  /* NO_SIGNALS */
        goto done;
    }
 
    /* Get the response to the transfer command we sent, to see if
     * they can accomodate the request.  If everything went okay,
     * we will get a preliminary response saying that the transfer
     * initiation was successful and that the data is there for
     * reading (for retrieves;  for sends, they will be waiting for
     * us to send them something).
     */
    rp = InitResponse();
    if (rp == NULL) {
        Error(cip, kDontPerror, "Malloc failed.\n");
        cip->errNo = kErrMallocFailed;
        result = cip->errNo;
        goto done;
    }
    result = GetResponse(cip, rp);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(0);
#endif  /* NO_SIGNALS */
 
    if (result < 0)
        goto done;
    respCode = rp->codeType;
    DoneWithResponse(cip, rp);
 
    if (respCode > 2) {
        cip->errNo = kErrCouldNotStartDataTransfer;
        result = cip->errNo;
        goto done;
    }
 
    /* Now we accept the data connection that the other side is offering
     * to us.  Then we can do the actual I/O on the data we want.
     */
    cip->netMode = netMode;
    if ((result = AcceptDataConnection(cip)) < 0)
        goto done;
    return (kNoErr);
 
done:
    (void) FTPEndDataCmd(cip, 0);
    return (result);
}   /* FTPStartDataCmd */

Referenced by FTPGetOneF(), FTPList(), FTPListToMemory2(), and FTPPutOneF().

◆ FTPStartIOTimer()

void FTPStartIOTimer ( const FTPCIPtr )

Definition at line 93 of file io.c.

{
    (void) gettimeofday(&cip->t0, NULL);
    if (cip->progress != (FTPProgressMeterProc) 0)
        (*cip->progress)(cip, kPrInitMsg);
}   /* FTPStartIOTimer */

Referenced by FTPGetOneF(), and FTPPutOneF().

◆ FTPStopIOTimer()

void FTPStopIOTimer ( const FTPCIPtr )

Definition at line 159 of file io.c.

{
    cip->nextProgressUpdate = 0;    /* force last update */
    FTPUpdateIOTimer(cip);
    if (cip->progress != (FTPProgressMeterProc) 0)
        (*cip->progress)(cip, kPrEndMsg);
}   /* FTPStopIOTimer */

Referenced by FTPGetOneF(), and FTPPutOneF().

◆ FTPStrError()

const char * FTPStrError ( int e )

Definition at line 114 of file errno.c.

{
    if (e == kErrGeneric) {
        return ("miscellaneous error");
    } else if (e == kNoErr) {
        return ("no error");
    } else {
        if (e < 0)
            e = -e;
        if ((e >= kErrFirst) && (e <= kErrLast)) {
            return (gErrList[e - kErrFirst]);
        }
    }
    return ("unrecognized error number");
}   /* FTPStrError */

Referenced by FTPPerror(), FTPPutOneF(), InitConnectionInfo(), and PreInit().

◆ FTPSymlink()

int FTPSymlink	(	const FTPCIPtr	cip,
		const char *const	lfrom,
		const char *const	lto
	)

Definition at line 1585 of file cmds.c.

{
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
    if ((cip == NULL) || (lfrom == NULL) || (lto == NULL))
        return (kErrBadParameter);
    if ((lfrom[0] == '\0') || (lto[0] == '\0'))
        return (kErrBadParameter);
    if (FTPCmd(cip, "SITE SYMLINK %s %s", lfrom, lto) == 2)
        return (kNoErr);
    return (kErrSYMLINKFailed);
}   /* FTPSymlink */

Referenced by FTPPutFiles3(), and SymlinkCmd().

◆ FTPUmask()

int FTPUmask	(	const FTPCIPtr	cip,
		const char *const	umsk
	)

Definition at line 1602 of file cmds.c.

{
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
    if ((umsk == NULL) || (umsk[0] == '\0'))
        return (kErrBadParameter);
    if (FTPCmd(cip, "SITE UMASK %s", umsk) == 2)
        return (kNoErr);
    return (kErrUmaskFailed);
}   /* FTPUmask */

Referenced by UmaskCmd().

◆ FTPUpdateIOTimer()

void FTPUpdateIOTimer ( const FTPCIPtr )

Definition at line 104 of file io.c.

{
    double sec;
    struct timeval *t0, t1;
    time_t now;
 
    (void) time(&now);
    if (now < cip->nextProgressUpdate)
        return;
    now += 1;
    cip->nextProgressUpdate = now;
 
    (void) gettimeofday(&t1, NULL);
    t0 = &cip->t0;
 
    if (t0->tv_usec > t1.tv_usec) {
        t1.tv_usec += 1000000;
        t1.tv_sec--;
    }
    sec = ((double) (t1.tv_usec - t0->tv_usec) * 0.000001)
        + (t1.tv_sec - t0->tv_sec);
    if (sec > 0.0) {
        cip->kBytesPerSec = ((double) cip->bytesTransferred) / (1024.0 * sec);
    } else {
        cip->kBytesPerSec = -1.0;
    }
    if (cip->expectedSize == kSizeUnknown) {
        cip->percentCompleted = -1.0;
        cip->secLeft = -1.0;
    } else if (cip->expectedSize <= 0) {
        cip->percentCompleted = 100.0;
        cip->secLeft = 0.0;
    } else {
        cip->percentCompleted = ((double) (100.0 * (cip->bytesTransferred + cip->startPoint))) / ((double) cip->expectedSize);
        if (cip->percentCompleted >= 100.0) {
            cip->percentCompleted = 100.0;
            cip->secLeft = 0.0;
        } else if (cip->percentCompleted <= 0.0) {
            cip->secLeft = 999.0;
        }
        if (cip->kBytesPerSec > 0.0) {
            cip->secLeft = ((cip->expectedSize - cip->bytesTransferred - cip->startPoint) / 1024.0) / cip->kBytesPerSec;
            if (cip->secLeft < 0.0)
                cip->secLeft = 0.0;
        }
    }
    cip->sec = sec;
    if ((cip->progress != (FTPProgressMeterProc) 0) && (cip->useProgressMeter != 0))
        (*cip->progress)(cip, kPrUpdateMsg);
}   /* FTPUpdateIOTimer */

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.

{
    char mstr[64], astr[64], cstr[64];
    int result;
    ResponsePtr rp;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    if (cip->hasUTIME == kCommandNotAvailable) {
        cip->errNo = kErrUTIMENotAvailable;
        result = kErrUTIMENotAvailable;
    } else {
        if ((actime == (time_t) 0) || (actime == (time_t) -1))
            (void) time(&actime);
        if ((modtime == (time_t) 0) || (modtime == (time_t) -1))
            (void) time(&modtime);
        if ((crtime == (time_t) 0) || (crtime == (time_t) -1))
            crtime = modtime;
 
        (void) GmTimeStr(astr, sizeof(astr), actime);
        (void) GmTimeStr(mstr, sizeof(mstr), modtime);
        (void) GmTimeStr(cstr, sizeof(cstr), crtime);
 
        rp = InitResponse();
        if (rp == NULL) {
            result = kErrMallocFailed;
            cip->errNo = kErrMallocFailed;
            Error(cip, kDontPerror, "Malloc failed.\n");
        } else {
            result = RCmd(cip, rp, "SITE UTIME %s %s %s %s UTC", file, astr, mstr, cstr);
            if (result < 0) {
                DoneWithResponse(cip, rp);
                return (result);
            } else if (result == 2) {
                cip->hasUTIME = kCommandAvailable;
                result = kNoErr;
            } else if (UNIMPLEMENTED_CMD(rp->code)) {
                cip->hasUTIME = kCommandNotAvailable;
                cip->errNo = kErrUTIMENotAvailable;
                result = kErrUTIMENotAvailable;
            } else {
                cip->errNo = kErrUTIMEFailed;
                result = kErrUTIMEFailed;
            }
            DoneWithResponse(cip, rp);
        }
    }
    return (result);
}   /* FTPUtime */

Referenced by FTPPutOneF().

◆ GetHomeDir()

void GetHomeDir	(	char *	dst,
		size_t	size
	)

Definition at line 240 of file util.c.

{
#if defined(WIN32) || defined(_WINDOWS)
    const char *homedrive, *homepath;
 
    homedrive = getenv("HOMEDRIVE");
    homepath = getenv("HOMEPATH");
    if ((homedrive != NULL) && (homepath != NULL)) {
        (void) Strncpy(dst, homedrive, size);
        (void) Strncat(dst, homepath, size);
        return;
    }
 
//  GetSpecialDir(dst, size, CSIDL_PERSONAL /* "My Documents" */);
//  if (dst[0] != '\0')
//      return;
//
//  dst[0] = '\0';
//  if (GetWindowsDirectory(dst, size - 1) < 1)
//      (void) Strncpy(dst, ".", size);
//  else if (dst[1] == ':') {
//      dst[2] = '\\';
//      dst[3] = '\0';
//  }
#else
    const char *cp;
    struct passwd *pw;
 
    pw = NULL;
#if defined(USE_GETPWUID)
    /* Try to use getpwuid(), but if we have to, fall back to getpwnam(). */
    if ((pw = getpwuid(getuid())) == NULL)
        pw = GetPwByName(); /* Oh well, try getpwnam() then. */
#else
    /* Try to use getpwnam(), but if we have to, fall back to getpwuid(). */
    if ((pw = GetPwByName()) == NULL)
        pw = getpwuid(getuid());    /* Try getpwnam() then. */
#endif
    if (pw != NULL)
        cp = pw->pw_dir;
    else if ((cp = (const char *) getenv("LOGNAME")) == NULL)
            cp = ".";
    (void) Strncpy(dst, cp, size);
#endif
}   /* GetHomeDir */

Referenced by ExpandTilde().

◆ GetPass()

char * GetPass ( const char *const prompt )

Definition at line 186 of file util.c.

{
#ifdef HAVE_GETPASS
    return getpass(prompt);
#elif defined(_CONSOLE) && (defined(WIN32) || defined(_WINDOWS))
    static char pwbuf[128];
    char *dst, *dlim;
    int c;
 
    (void) memset(pwbuf, 0, sizeof(pwbuf));
    if (! _isatty(_fileno(stdout)))
        return (pwbuf);
    (void) fputs(prompt, stdout);
    (void) fflush(stdout);
 
    for (dst = pwbuf, dlim = dst + sizeof(pwbuf) - 1;;) {
        c = _getch();
        if ((c == 0) || (c == 0xe0)) {
            /* The key is a function or arrow key; read and discard. */
            (void) _getch();
        }
        if ((c == '\r') || (c == '\n'))
            break;
        if (dst < dlim)
            *dst++ = c;
    }
    *dst = '\0';
 
    (void) fflush(stdout);
    (void) fflush(stdin);
    return (pwbuf);
#else
    static char pwbuf[128];
 
    (void) memset(pwbuf, 0, sizeof(pwbuf));
#if defined(WIN32) || defined(_WINDOWS)
    if (! _isatty(_fileno(stdout)))
#else
    if (! isatty(1))
#endif
        return (pwbuf);
    (void) fputs(prompt, stdout);
    (void) fflush(stdout);
    (void) FGets(pwbuf, sizeof(pwbuf), stdin);
    (void) fflush(stdout);
    (void) fflush(stdin);
    return (pwbuf);
#endif
}   /* GetPass */

Referenced by DECLARE_INTERFACE_().

◆ GetResponse()

int GetResponse	(	const	FTPCIPtr,
		ResponsePtr	rp
	)

Definition at line 287 of file rcmd.c.

{
    longstring str;
    int eofError;
    str16 code;
    char *cp;
    int continuation;
    volatile FTPCIPtr vcip;
#ifdef NO_SIGNALS
    int result;
#else   /* NO_SIGNALS */
    volatile FTPSigProc osigpipe;
    int sj;
#endif  /* NO_SIGNALS */
 
    /* RFC 959 states that a reply may span multiple lines.  A single
     * line message would have the 3-digit code <space> then the msg.
     * A multi-line message would have the code <dash> and the first
     * line of the msg, then additional lines, until the last line,
     * which has the code <space> and last line of the msg.
     *
     * For example:
     *  123-First line
     *  Second line
     *  234 A line beginning with numbers
     *  123 The last line
     */
 
#ifdef NO_SIGNALS
    vcip = cip;
#else   /* NO_SIGNALS */
    osigpipe = (volatile FTPSigProc) signal(SIGPIPE, BrokenCtrl);
    vcip = cip;
 
#ifdef HAVE_SIGSETJMP
    sj = sigsetjmp(gBrokenCtrlJmp, 1);
#else
    sj = setjmp(gBrokenCtrlJmp);
#endif  /* HAVE_SIGSETJMP */
 
    if (sj != 0) {
        (void) signal(SIGPIPE, (FTPSigProc) osigpipe);
        FTPShutdownHost(vcip);
        vcip->errNo = kErrRemoteHostClosedConnection;
        return(vcip->errNo);
    }
#endif  /* NO_SIGNALS */
 
#ifdef NO_SIGNALS
    cp = str;
    eofError = 0;
    if (cip->dataTimedOut > 0) {
        /* Give up immediately unless the server had already
         * sent a message. Odds are since the data is timed
         * out, so is the control.
         */
        if (SWaitUntilReadyForReading(cip->ctrlSocketR, 0) == 0) {
            /* timeout */
            Error(cip, kDontPerror, "Could not read reply from control connection -- timed out.\n");
            FTPShutdownHost(vcip);
            cip->errNo = kErrControlTimedOut;
            return (cip->errNo);
        }
    }
    result = SReadline(&cip->ctrlSrl, str, sizeof(str) - 1);
    if (result == kTimeoutErr) {
        /* timeout */
        Error(cip, kDontPerror, "Could not read reply from control connection -- timed out.\n");
        FTPShutdownHost(vcip);
        cip->errNo = kErrControlTimedOut;
        return (cip->errNo);
    } else if (result == 0) {
        /* eof */
        eofError = 1;
        rp->hadEof = 1;
        if (rp->eofOkay == 0)
            Error(cip, kDontPerror, "Remote host has closed the connection.\n");
        FTPShutdownHost(vcip);
        cip->errNo = kErrRemoteHostClosedConnection;
        return (cip->errNo);
    } else if (result < 0) {
        /* error */
        Error(cip, kDoPerror, "Could not read reply from control connection");
        FTPShutdownHost(vcip);
        cip->errNo = kErrInvalidReplyFromServer;
        return (cip->errNo);
    }
 
    if (str[result - 1] == '\n')
        str[result - 1] = '\0';
 
#else   /* NO_SIGNALS */
    /* Get the first line of the response. */
    eofError = GetTelnetString(cip, str, sizeof(str), cip->cin, cip->cout);
 
    cp = str;
    if (*cp == '\0') {
        if (eofError < 0) {
            /* No bytes read for reply, and EOF detected. */
            rp->hadEof = 1;
            if (rp->eofOkay == 0)
                Error(cip, kDontPerror, "Remote host has closed the connection.\n");
            FTPShutdownHost(vcip);
            cip->errNo = kErrRemoteHostClosedConnection;
            (void) signal(SIGPIPE, osigpipe);
            return(cip->errNo);
        }
    }
#endif  /* NO_SIGNALS */
 
    if (!isdigit((int) *cp)) {
        Error(cip, kDontPerror, "Invalid reply: \"%s\"\n", cp);
        cip->errNo = kErrInvalidReplyFromServer;
#ifndef NO_SIGNALS
        (void) signal(SIGPIPE, osigpipe);
#endif
        return (cip->errNo);
    }
 
    rp->codeType = *cp - '0';
    cp += 3;
    continuation = (*cp == '-');
    *cp++ = '\0';
    (void) STRNCPY(code, str);
    rp->code = atoi(code);
    (void) AddLine(&rp->msg, cp);
    if (eofError < 0) {
        /* Read reply, but EOF was there also. */
        rp->hadEof = 1;
    }
 
    while (continuation) {
 
#ifdef NO_SIGNALS
        result = SReadline(&cip->ctrlSrl, str, sizeof(str) - 1);
        if (result == kTimeoutErr) {
            /* timeout */
            Error(cip, kDontPerror, "Could not read reply from control connection -- timed out.\n");
            FTPShutdownHost(vcip);
            cip->errNo = kErrControlTimedOut;
            return (cip->errNo);
        } else if (result == 0) {
            /* eof */
            eofError = 1;
            rp->hadEof = 1;
            if (rp->eofOkay == 0)
                Error(cip, kDontPerror, "Remote host has closed the connection.\n");
            FTPShutdownHost(vcip);
            cip->errNo = kErrRemoteHostClosedConnection;
            return (cip->errNo);
        } else if (result < 0) {
            /* error */
            Error(cip, kDoPerror, "Could not read reply from control connection");
            FTPShutdownHost(vcip);
            cip->errNo = kErrInvalidReplyFromServer;
            return (cip->errNo);
        }
 
        if (str[result - 1] == '\n')
            str[result - 1] = '\0';
#else   /* NO_SIGNALS */
        eofError = GetTelnetString(cip, str, sizeof(str), cip->cin, cip->cout);
        if (eofError < 0) {
            /* Read reply, but EOF was there also. */
            rp->hadEof = 1;
            continuation = 0;
        }
#endif  /* NO_SIGNALS */
        cp = str;
        if (strncmp(code, cp, SZ(3)) == 0) {
            cp += 3;
            if (*cp == ' ')
                continuation = 0;
            ++cp;
        }
        (void) AddLine(&rp->msg, cp);
    }
 
    if (rp->code == 421) {
        /*
         *   421 Service not available, closing control connection.
         *       This may be a reply to any command if the service knows it
         *       must shut down.
         */
        if (rp->eofOkay == 0)
            Error(cip, kDontPerror, "Remote host has closed the connection.\n");
        FTPShutdownHost(vcip);
        cip->errNo = kErrRemoteHostClosedConnection;
#ifndef NO_SIGNALS
        (void) signal(SIGPIPE, osigpipe);
#endif
        return(cip->errNo);
    }
 
#ifndef NO_SIGNALS
    (void) signal(SIGPIPE, osigpipe);
#endif
    return (kNoErr);
}   /* GetResponse */

Referenced by FTPAbortDataTransfer(), FTPCmd(), FTPEndDataCmd(), FTPStartDataCmd(), OpenControlConnection(), and RCmd().

◆ GetTelnetString()

int GetTelnetString	(	const	FTPCIPtr,
		char *	,
		size_t	,
		FILE *	,
		FILE *
	)

Referenced by GetResponse().

◆ GetUsrName()

void GetUsrName	(	char *	dst,
		size_t	size
	)

Definition at line 290 of file util.c.

{
#if defined(WIN32) || defined(_WINDOWS)
    DWORD size1;
 
    size1 = size - 1;
    if (! GetUserName(dst, &size1))
        (void) strncpy(dst, "unknown", size);
    dst[size - 1] = '\0';
#else
    const char *cp;
    struct passwd *pw;
 
    pw = NULL;
#ifdef USE_GETPWUID
    /* Try to use getpwuid(), but if we have to, fall back to getpwnam(). */
    if ((pw = getpwuid(getuid())) == NULL)
        pw = GetPwByName(); /* Oh well, try getpwnam() then. */
#else
    /* Try to use getpwnam(), but if we have to, fall back to getpwuid(). */
    if ((pw = GetPwByName()) == NULL)
        pw = getpwuid(getuid());    /* Try getpwnam() then. */
#endif
    if (pw != NULL)
        cp = pw->pw_name;
    else if ((cp = (const char *) getenv("LOGNAME")) == NULL)
            cp = "UNKNOWN";
    (void) Strncpy(dst, cp, size);
#endif
}   /* GetUserName */

Referenced by FTPInitializeAnonPassword().

◆ InitFileInfo()

void InitFileInfo ( FileInfoPtr fip )

Definition at line 471 of file linelist.c.

{
    (void) memset(fip, 0, sizeof(FileInfo));
    fip->type = '-';
    fip->size = kSizeUnknown;
    fip->mdtm = kModTimeUnknown;
}   /* InitFileInfoList */

Referenced by ConcatFileToFileInfoList().

◆ InitFileInfoList()

void InitFileInfoList ( FileInfoListPtr list )

Definition at line 193 of file linelist.c.

{
    (void) memset(list, 0, sizeof(FileInfoList));
}   /* InitFileInfoList */

Referenced by FTPLocalRecursiveFileList2(), FTPRemoteRecursiveFileList(), FTPRemoteRecursiveFileList1(), LineListToFileInfoList(), LineToFileInfoList(), Ls(), UnLslR(), and UnMlsD().

◆ InitLineList()

void InitLineList ( LineListPtr list )

Definition at line 54 of file linelist.c.

{
    (void) memset(list, 0, sizeof(LineList));
}   /* InitLineList */

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.

{
    ResponsePtr rp;
 
    rp = (ResponsePtr) calloc(SZ(1), sizeof(Response));
    if (rp != NULL)
        InitLineList(&rp->msg);
    return (rp);
}   /* InitResponse */

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.

{
    LinePtr lp, lp2;
 
    InitFileInfoList(dst);
    for (lp = src->first; lp != NULL; lp = lp2) {
        lp2 = lp->next;
        if (ConcatFileToFileInfoList(dst, lp->line) < 0)
            return (-1);
    }
    return (0);
}   /* LineListToFileList */

Referenced by FTPPutFiles3().

◆ LineToFileInfoList()

int LineToFileInfoList	(	LinePtr	lp,
		FileInfoListPtr	dst
	)

Definition at line 775 of file linelist.c.

{
    InitFileInfoList(dst);
    if (ConcatFileToFileInfoList(dst, lp->line) < 0)
        return (-1);
    return (0);
}   /* LineToFileInfoList */

Referenced by FTPGetFiles3().

◆ MkDirs()

int MkDirs	(	const char * const	newdir,
		int	mode1
	)

Definition at line 785 of file util.c.

{
    char s[512];
    int rc;
    char *cp, *sl;
#if defined(WIN32) || defined(_WINDOWS)
    struct _stat st;
    char *share;
#else
    struct Stat st;
    mode_t mode = (mode_t) mode1;
#endif
 
#if defined(WIN32) || defined(_WINDOWS)
    if ((isalpha(newdir[0])) && (newdir[1] == ':')) {
        if (! IsLocalPathDelim(newdir[2])) {
            /* Special case "c:blah", and errout.
             * "c:\blah" must be used or _access GPFs.
             */
            errno = EINVAL;
            return (-1);
        } else if (newdir[3] == '\0') {
            /* Special case root directory, which cannot be made. */
            return (0);
        }
    } else if (IsUNCPrefixed(newdir)) {
        share = StrFindLocalPathDelim(newdir + 2);
        if ((share == NULL) || (StrFindLocalPathDelim(share + 1) == NULL))
            return (-1);
    }
 
    if (_access(newdir, 00) == 0) {
        if (_stat(newdir, &st) < 0)
            return (-1);
        if (! S_ISDIR(st.st_mode)) {
            errno = ENOTDIR;
            return (-1);
        }
        return 0;
    }
#else
    if (access(newdir, F_OK) == 0) {
        if (Stat(newdir, &st) < 0)
            return (-1);
        if (! S_ISDIR(st.st_mode)) {
            errno = ENOTDIR;
            return (-1);
        }
        return 0;
    }
#endif
 
    (void) strncpy(s, newdir, sizeof(s));
    if (s[sizeof(s) - 1] != '\0') {
#ifdef ENAMETOOLONG
        errno = ENAMETOOLONG;
#else
        errno = EINVAL;
        return (-1);
#endif
    }
 
    cp = StrRFindLocalPathDelim(s);
    if (cp == NULL) {
#if defined(WIN32) || defined(_WINDOWS)
        if (! CreateDirectory(newdir, (LPSECURITY_ATTRIBUTES) 0))
            return (-1);
        return (0);
#else
        rc = mkdir(newdir, mode);
        return (rc);
#endif
    } else if (cp[1] == '\0') {
        /* Remove trailing slashes from path. */
        --cp;
        while (cp > s) {
            if (! IsLocalPathDelim(*cp))
                break;
            --cp;
        }
        cp[1] = '\0';
        cp = StrRFindLocalPathDelim(s);
        if (cp == NULL) {
#if defined(WIN32) || defined(_WINDOWS)
            if (! CreateDirectory(s, (LPSECURITY_ATTRIBUTES) 0))
                return (-1);
#else
            rc = mkdir(s, mode);
            return (rc);
#endif
        }
    }
 
    /* Find the deepest directory in this
     * path that already exists.  When
     * we do, we want to have the 's'
     * string as it was originally, but
     * with 'cp' pointing to the first
     * slash in the path that starts the
     * part that does not exist.
     */
    sl = NULL;
    for (;;) {
        *cp = '\0';
#if defined(WIN32) || defined(_WINDOWS)
        rc = _access(s, 00);
#else
        rc = access(s, F_OK);
#endif
        if (sl != NULL)
            *sl = LOCAL_PATH_DELIM;
        if (rc == 0) {
            *cp = LOCAL_PATH_DELIM;
            break;
        }
        sl = cp;
        cp = StrRFindLocalPathDelim(s);
        if (cp == NULL) {
            /* We do not have any more
             * slashes, so none of the
             * new directory's components
             * existed before, so we will
             * have to make everything
             * starting at the first node.
             */
            if (sl != NULL)
                *sl = LOCAL_PATH_DELIM;
 
            /* We refer to cp + 1 below,
             * so this is why we can
             * set "cp" to point to the
             * byte before the array starts.
             */
            cp = s - 1;
            break;
        }
    }
 
    for (;;) {
        /* Extend the path we have to
         * include the next component
         * to make.
         */
        sl = StrFindLocalPathDelim(cp + 1);
        if (sl == s) {
            /* If the next slash is pointing
             * to the start of the string, then
             * the path is an absolute path and
             * we don't need to make the root node,
             * and besides the next mkdir would
             * try an empty string.
             */
            ++cp;
            sl = StrFindLocalPathDelim(cp + 1);
        }
        if (sl != NULL) {
            *sl = '\0';
        }
#if defined(WIN32) || defined(_WINDOWS)
        if (! CreateDirectory(s, (LPSECURITY_ATTRIBUTES) 0))
            return (-1);
#else
        rc = mkdir(s, mode);
        if (rc < 0)
            return rc;
#endif
        if (sl == NULL)
            break;
        *sl = LOCAL_PATH_DELIM;
        cp = sl;
    }
    return (0);
}   /* MkDirs */

Referenced by FTPGetFiles3(), InitOurDirectory(), LocalMkdirCmd(), and MkSpoolDir().

◆ PrintResponse()

void PrintResponse	(	const	FTPCIPtr,
		LineListPtr	llp
	)

Definition at line 74 of file rcmd.c.

{
    LinePtr lp;
 
    if (llp != NULL) {
        for (lp = llp->first; lp != NULL; lp = lp->next)
            PrintF(cip, "%s\n", lp->line);
    }
}   /* PrintResponse */

◆ RCmd()

int RCmd	(	const	FTPCIPtr,
		ResponsePtr	rp,
		const char *	cmdspec,
			...
	)

Definition at line 718 of file rcmd.c.

{
    va_list ap;
    int result;
 
    if (cip == NULL)
        return (kErrBadParameter);
    if (strcmp(cip->magic, kLibraryMagic))
        return (kErrBadMagic);
 
    va_start(ap, cmdspec);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(cip->ctrlTimeout);
#endif  /* NO_SIGNALS */
    result = SendCommand(cip, cmdspec, ap);
    va_end(ap);
    if (result < 0) {
#ifndef NO_SIGNALS
        if (cip->ctrlTimeout > 0)
            (void) alarm(0);
#endif  /* NO_SIGNALS */
        return (result);
    }
 
    /* Get the response to the command we sent. */
    result = GetResponse(cip, rp);
#ifndef NO_SIGNALS
    if (cip->ctrlTimeout > 0)
        (void) alarm(0);
#endif  /* NO_SIGNALS */
 
    if (result == kNoErr)
        result = rp->codeType;
    return (result);
}   /* 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.

{
    if (rp != NULL) {
        TraceResponse(cip, rp);
        if (cip->printResponseProc != 0) {
            if ((rp->printMode & kResponseNoProc) == 0)
                (*cip->printResponseProc)(cip, rp);
        }
        if ((rp->printMode & kResponseNoSave) == 0)
            SaveLastResponse(cip, rp);
        else
            DisposeLineListContents(&rp->msg);
        (void) memset(rp, 0, sizeof(Response));
    }
}   /* ReInitResponse */

Referenced by FTPLoginHost(), and FTPQueryFeatures().

◆ RemoveFileInfo()

FileInfoPtr RemoveFileInfo	(	FileInfoListPtr	list,
		FileInfoPtr	killMe
	)

Definition at line 483 of file linelist.c.

{
    FileInfoPtr nextFileInfo, prevFileInfo;
 
    nextFileInfo = killMe->next;
    prevFileInfo = killMe->prev;
    if (killMe->lname != NULL) {
        killMe->lname[0] = '\0';        /* Make it useless just in case. */
        free(killMe->lname);
    }
    if (killMe->relname != NULL) {
        killMe->relname[0] = '\0';
        free(killMe->relname);
    }
    if (killMe->rname != NULL) {
        killMe->rname[0] = '\0';
        free(killMe->rname);
    }
    if (killMe->rlinkto != NULL) {
        killMe->rlinkto[0] = '\0';
        free(killMe->rlinkto);
    }
    if (killMe->plug != NULL) {
        killMe->plug[0] = '\0';
        free(killMe->plug);
    }
 
    if (list->first == killMe)
        list->first = nextFileInfo;
    if (list->last == killMe)
        list->last = prevFileInfo;
 
    if (nextFileInfo != NULL)
        nextFileInfo->prev = prevFileInfo;
    if (prevFileInfo != NULL)
        prevFileInfo->next = nextFileInfo;
 
    free(killMe);
    list->nFileInfos--;
    return (nextFileInfo);
}   /* RemoveFileInfo */

◆ RemoveLine()

LinePtr RemoveLine	(	LineListPtr	list,
		LinePtr	killMe
	)

Definition at line 63 of file linelist.c.

{
    LinePtr nextLine, prevLine;
 
    nextLine = killMe->next;
    prevLine = killMe->prev;
    if (killMe->line != NULL) {
        killMe->line[0] = '\0';     /* Make it useless just in case. */
        free(killMe->line);
    }
 
    if (list->first == killMe)
        list->first = nextLine;
    if (list->last == killMe)
        list->last = prevLine;
 
    if (nextLine != NULL)
        nextLine->prev = prevLine;
    if (prevLine != NULL)
        prevLine->next = nextLine;
 
    free(killMe);
    list->nLines--;
    return (nextLine);
}   /* RemoveLine */

Referenced by FTPRemoteGlob(), and RemoteGlobCollapse().

◆ Scramble()

void Scramble	(	unsigned char *	dst,
		size_t	dsize,
		unsigned char *	src,
		char *	key
	)

Definition at line 607 of file util.c.

{
    int i;
    unsigned int ch;
    unsigned char *k2;
    size_t keyLen;
 
    keyLen = strlen(key);
    k2 = (unsigned char *) key;
    for (i=0; i < (int) dsize - 1; i++) {
        ch = src[i];
        if (ch == 0)
            break;
        dst[i] = (unsigned char) (ch ^ (int) (k2[i % (int) keyLen]));
    }
    dst[i] = '\0';
}   /* Scramble */

◆ SortFileInfoList()

void SortFileInfoList	(	FileInfoListPtr	list,
		int	sortKey,
		int	sortOrder
	)

Definition at line 353 of file linelist.c.

{
    FileInfoVec fiv;
    FileInfoPtr fip;
    int i, j, n, n2;
 
    fiv = list->vec;
    if (fiv == NULL)
        return;
 
    if (list->sortKey == sortKey) {
        if (list->sortOrder == sortOrder)
            return;     /* Already sorted they you want. */
 
        /* Reverse the sort. */
        n = list->nFileInfos;
        if (n > 1) {
            n2 = n / 2;
            for (i=0; i<n2; i++) {
                j = n - i - 1;
                fip = fiv[i];
                fiv[i] = fiv[j];
                fiv[j] = fip;
            }
        }
 
        list->sortOrder = sortOrder;
    } else if ((sortKey == 'n') && (sortOrder == 'a')) {
        qsort(fiv, (size_t) list->nFileInfos, sizeof(FileInfoPtr),
            NameCmp);
        list->sortKey = sortKey;
        list->sortOrder = sortOrder;
    } else if ((sortKey == 'n') && (sortOrder == 'd')) {
        qsort(fiv, (size_t) list->nFileInfos, sizeof(FileInfoPtr),
            ReverseNameCmp);
        list->sortKey = sortKey;
        list->sortOrder = sortOrder;
    } else if ((sortKey == 't') && (sortOrder == 'a')) {
        qsort(fiv, (size_t) list->nFileInfos, sizeof(FileInfoPtr),
            TimeCmp);
        list->sortKey = sortKey;
        list->sortOrder = sortOrder;
    } else if ((sortKey == 't') && (sortOrder == 'd')) {
        qsort(fiv, (size_t) list->nFileInfos, sizeof(FileInfoPtr),
            ReverseTimeCmp);
        list->sortKey = sortKey;
        list->sortOrder = sortOrder;
    } else if ((sortKey == 's') && (sortOrder == 'a')) {
        qsort(fiv, (size_t) list->nFileInfos, sizeof(FileInfoPtr),
            SizeCmp);
        list->sortKey = sortKey;
        list->sortOrder = sortOrder;
    } else if ((sortKey == 's') && (sortOrder == 'd')) {
        qsort(fiv, (size_t) list->nFileInfos, sizeof(FileInfoPtr),
            ReverseSizeCmp);
        list->sortKey = sortKey;
        list->sortOrder = sortOrder;
    } else if (sortKey == 'b') {
        /* This is different from the rest. */
        list->sortKey = sortKey;
        list->sortOrder = sortOrder;
        qsort(fiv, (size_t) list->nFileInfos, sizeof(FileInfoPtr),
            BreadthFirstCmp);
    }
}   /* SortFileInfoList */

Referenced by GetLsCacheFileList(), and Ls().

◆ StrDup()

char * StrDup ( const char * buf )

Definition at line 12 of file linelist.c.

{
    char *cp;
    size_t len;
 
    if (buf == NULL)
        return (NULL);
 
    len = strlen(buf) + 1;
    cp = (char *) malloc(len);
    if (cp != NULL)
        (void) memcpy(cp, buf, len);
    return (cp);
}   /* StrDup */

◆ StrRemoveTrailingSlashes()

void StrRemoveTrailingSlashes ( char * dst )

Definition at line 768 of file util.c.

{
    char *cp;
 
    cp = strrchr(dst, '/');
    if ((cp == NULL) || (cp[1] != '\0'))
        return;
 
    /* Note: Do not destroy a path of "/" */
    while ((cp > dst) && (*cp == '/'))
        *cp-- = '\0';
}   /* StrRemoveTrailingSlashes */

Referenced by FTPGetFiles3(), GetCmd(), PutCmd(), SpoolGetCmd(), and SpoolPutCmd().

◆ TraceResponse()

void TraceResponse	(	const	FTPCIPtr,
		ResponsePtr	rp
	)

Definition at line 55 of file rcmd.c.

{
    LinePtr lp;
 
    if (rp != NULL) {
        lp = rp->msg.first;
        if (lp != NULL) {
            PrintF(cip, "%3d: %s\n", rp->code, lp->line);
            for (lp = lp->next; lp != NULL; lp = lp->next)
                PrintF(cip, "     %s\n", lp->line);
        }
    }
}   /* TraceResponse */

Referenced by DoneWithResponse(), and ReInitResponse().

◆ UnLslR()

int UnLslR	(	FileInfoListPtr	filp,
		LineListPtr	llp,
		int	serverType
	)

Definition at line 561 of file glob.c.

{
    char curdir[256];
    char line[256];
    int hadblankline = 0;
    int len;
    size_t curdirlen = 0;
    char fname[256];
    char linkto[256];
    char *cp;
    longest_int fsize;
    int ftype;
    time_t ftime, now;
    int thisyear;
    struct tm *nowtm;
    int rc;
    LinePtr lp;
    FileInfo fi;
    int linesread = 0;
    int linesconverted = 0;
    size_t maxFileLen = 0;
    size_t maxPlugLen = 0;
    size_t fileLen;
    int plugend;
 
    (void) time(&now);
    nowtm = localtime(&now);
    if (nowtm == NULL)
        thisyear = 1970;    /* should never happen */
    else
        thisyear = nowtm->tm_year + 1900;
 
    curdir[0] = '\0';
 
    InitFileInfoList(filp);
    for (lp = llp->first; lp != NULL; lp = lp->next) {
        len = (int) strlen(STRNCPY(line, lp->line));
        if ((line[0] == 't') && (strncmp(line, "total", 5) == 0)) {
            /* total XX line? */
            if (line[len - 1] != ':') {
                hadblankline = 0;
                continue;
            }
            /* else it was a subdir named total */
        } else {
            for (cp = line; ; cp++) {
                if ((*cp == '\0') || (!isspace((int) *cp)))
                    break;
            }
            if (*cp == '\0') {
                /* Entire line was blank. */
                /* separator line between dirs */
                hadblankline = 1;
                continue;
            }
        }
 
        if ((hadblankline != 0) && (line[len - 1] == ':')) {
            /* newdir */
            hadblankline = 0;
            if ((line[0] == '.') && (line[1] == '/')) {
                line[len - 1] = '/';
                (void) memcpy(curdir, line + 2, (size_t) len + 1 - 2);
                curdirlen = (size_t) (len - 2);
            } else if ((line[0] == '.') && (line[1] == '\\')) {
                line[len - 1] = '\\';
                (void) memcpy(curdir, line + 2, (size_t) len + 1 - 2);
                curdirlen = (size_t) (len - 2);
            } else {
                line[len - 1] = '/';
                (void) memcpy(curdir, line, (size_t) len + 1);
                curdirlen = (size_t) len;
            }
            continue;
        }
 
        linesread++;
        rc = UnLslRLine(line, curdir, curdirlen, fname, sizeof(fname), linkto, sizeof(linkto), &ftype, &fsize, &ftime, now, thisyear, &plugend);
        if ((rc < 0) && (serverType == kServerTypeMicrosoftFTP)) {
            rc = UnDosLine(line, curdir, curdirlen, fname, sizeof(fname), &ftype, &fsize, &ftime);
            if (rc == 0) {
                *linkto = '\0';
                plugend = 0;
            }
        }
        if (rc == 0) {
            linesconverted++;
            fileLen = strlen(fname);
            if (fileLen > maxFileLen)
                maxFileLen = fileLen;
            fi.relnameLen = fileLen;
            fi.relname = StrDup(fname);
            fi.rname = NULL;
            fi.lname = NULL;
            fi.rlinkto = (linkto[0] == '\0') ? NULL : StrDup(linkto);
            fi.mdtm = ftime;
            fi.size = (longest_int) fsize;
            fi.type = ftype;
            if (plugend > 0) {
                fi.plug = (char *) malloc((size_t) plugend + 1);
                if (fi.plug != NULL) {
                    (void) memcpy(fi.plug, line, (size_t) plugend);
                    fi.plug[plugend] = '\0';
                    if ((size_t) plugend > maxPlugLen)
                        maxPlugLen = (size_t) plugend;
                }
            } else {
                fi.plug = (char *) malloc(32);
                if (fi.plug != NULL) {
                    strcpy(fi.plug, "----------   1 ftpuser  ftpusers");
                    fi.plug[0] = (char) ftype;
                    if (30 > maxPlugLen)
                        maxPlugLen = (size_t) 30;
                }
            }
            (void) AddFileInfo(filp, &fi);
        }
 
        hadblankline = 0;
    }
 
    filp->maxFileLen = maxFileLen;
    filp->maxPlugLen = maxPlugLen;
    if (linesread == 0)
        return (0);
    return ((linesconverted > 0) ? linesconverted : (-1));
}   /* UnLslR */

Referenced by FTPRemoteRecursiveFileList(), FTPRemoteRecursiveFileList1(), and Ls().

◆ UnMDTMDate()

time_t UnMDTMDate ( char * dstr )

Definition at line 486 of file util.c.

{
#ifndef HAVE_MKTIME
    return (kModTimeUnknown);
#else
    struct tm ut, *t;
    time_t mt, now;
    time_t result = kModTimeUnknown;
 
    if (strncmp(dstr, "19100", 5) == 0) {
        /* Server Y2K bug! */
        return (result);
    }
 
    (void) time(&now);
    t = localtime(&now);
 
    /* Copy the whole structure of the 'tm' pointed to by t, so it will
     * also set all fields we don't specify explicitly to be the same as
     * they were in t.  That way we copy non-standard fields such as
     * tm_gmtoff, if it exists or not.
     */
    ut = *t;
 
    /* The time we get back from the server is (should be) in UTC. */
    if (sscanf(dstr, "%04d%02d%02d%02d%02d%02d",
        &ut.tm_year,
        &ut.tm_mon,
        &ut.tm_mday,
        &ut.tm_hour,
        &ut.tm_min,
        &ut.tm_sec) == 6)
    {
        --ut.tm_mon;
        ut.tm_year -= 1900;
        mt = mktime(&ut);
        if (mt != (time_t) -1) {
            mt += GetUTCOffset(ut.tm_mon, ut.tm_mday);
            result = (time_t) mt;
        }
    }
    return result;
#endif  /* HAVE_MKTIME */
}   /* UnMDTMDate */

Referenced by FTPFileModificationTime(), and UnMlsT().

◆ UnMlsD()

int UnMlsD	(	FileInfoListPtr	filp,
		LineListPtr	llp
	)

Definition at line 827 of file glob.c.

{
    MLstItem mli;
    char plug[64];
    char og[32];
    int rc;
    LinePtr lp;
    FileInfo fi;
    int linesread = 0;
    int linesconverted = 0;
    int linesignored = 0;
    size_t maxFileLen = 0;
    size_t maxPlugLen = 0;
    size_t fileLen, plugLen;
    int m1, m2, m3;
    const char *cm1, *cm2, *cm3;
 
    InitFileInfoList(filp);
    for (lp = llp->first; lp != NULL; lp = lp->next) {
        linesread++;
        rc = UnMlsT(lp->line, &mli);
        if (rc == 0) {
            linesconverted++;
            fileLen = strlen(mli.fname);
            if (fileLen > maxFileLen)
                maxFileLen = fileLen;
            fi.relnameLen = fileLen;
            fi.relname = StrDup(mli.fname);
            fi.rname = NULL;
            fi.lname = NULL;
            fi.rlinkto = (mli.linkto[0] == '\0') ? NULL : StrDup(mli.linkto);
            fi.mdtm = mli.ftime;
            fi.size = (longest_int) mli.fsize;
            fi.type = mli.ftype;
            plug[0] = (char) mli.ftype;
            plug[1] = '\0';
            m1 = 0;
            m2 = 0;
            m3 = -1;
            if (mli.mode != (-1)) {
                m1 = (mli.mode & 00700) >> 6;
                m2 = (mli.mode & 00070) >> 3;
                m3 = (mli.mode & 00007);
            }
            if (mli.perm[0] != '\0') {
                m3 = 0;
                if (fi.type == 'd') {
                    if (strchr(mli.perm, 'e') != NULL) {
                        /* execute -> execute */
                        m3 |= 00001;
                    }
                    if (strchr(mli.perm, 'c') != NULL) {
                        /* create -> write */
                        m3 |= 00002;
                    }
                    if (strchr(mli.perm, 'l') != NULL) {
                        /* list -> read */
                        m3 |= 00004;
                    }
                } else {
                    if (strchr(mli.perm, 'w') != NULL) {
                        /* write -> write */
                        m3 |= 00002;
                    }
                    if (strchr(mli.perm, 'r') != NULL) {
                        /* read -> read */
                        m3 |= 00004;
                    }
                }
            }
            if (m3 != (-1)) {
                cm1 = rwx[m1];
                cm2 = rwx[m2];
                cm3 = rwx[m3];
                sprintf(plug + 1, "%s%s%s", cm1, cm2, cm3);
            }
            if (mli.owner[0] != '\0') {
                if (mli.group[0] != '\0') {
#ifdef HAVE_SNPRINTF
                    snprintf(og, sizeof(og) - 1,
#else
                    sprintf(og,
#endif  /* HAVE_SNPRINTF */
                        "   %-8.8s %s",
                        mli.owner, mli.group
                    );
                    STRNCAT(plug, og);
                } else {
                    STRNCAT(plug, "   ");
                    STRNCAT(plug, mli.owner);
                }
            }
            fi.plug = StrDup(plug);
            if (fi.plug != NULL) {
                plugLen = strlen(plug);
                if (plugLen > maxPlugLen)
                    maxPlugLen = plugLen;
            }
            (void) AddFileInfo(filp, &fi);
        } else if (rc == (-2)) {
            linesignored++;
        }
    }
 
    filp->maxFileLen = maxFileLen;
    filp->maxPlugLen = maxPlugLen;
    if (linesread == 0)
        return (0);
    linesconverted += linesignored;
    return ((linesconverted > 0) ? linesconverted : (-1));
}   /* UnMlsD */

Referenced by Ls().

◆ UnMlsT()

int UnMlsT	(	const char * const	line0,
		const	MLstItemPtr
	)

Definition at line 693 of file glob.c.

{
    char *cp, *val, *fact;
    int ec;
    size_t len;
    char line[1024];
 
    memset(mlip, 0, sizeof(MLstItem));
    mlip->mode = -1;
    mlip->fsize = kSizeUnknown;
    mlip->ftype = '-';
    mlip->ftime = kModTimeUnknown;
 
    len = strlen(line0);
    if (len > (sizeof(line) - 1))
        return (-1);    /* Line too long, sorry. */
    /* This should be re-coded so does not need to make a
     * copy of the buffer; it could be done in place.
     */
    memcpy(line, line0, len + 1);
 
    /* Skip leading whitespace. */
    for (cp = line; *cp != '\0'; cp++) {
        if (! isspace(*cp))
            break;
    }
 
    while (*cp != '\0') {
        for (fact = cp; ; cp++) {
            if ((*cp == '\0') || (*cp == ' ')) {
                /* protocol violation */
                return (-1);
            }
            if (*cp == '=') {
                /* End of fact name. */
                *cp++ = '\0';
                break;
            }
        }
        for (val = cp; ; cp++) {
            if (*cp == '\0') {
                /* protocol violation */
                return (-1);
            }
            if (*cp == ' ') {
                ec = ' ';
                *cp++ = '\0';
                break;
            } else if (*cp == ';') {
                if (cp[1] == ' ') {
                    ec = ' ';
                    *cp++ = '\0';
                    *cp++ = '\0';
                } else {
                    ec = ';';
                    *cp++ = '\0';
                }
                break;
            }
        }
        if (ISTRNEQ(fact, "OS.", 3))
            fact += 3;
        if (ISTREQ(fact, "type")) {
            if (ISTREQ(val, "file")) {
                mlip->ftype = '-';
            } else if (ISTREQ(val, "dir")) {
                mlip->ftype = 'd';
            } else if (ISTREQ(val, "cdir")) {
                /* not supported: current directory */
                return (-2);
            } else if (ISTREQ(val, "pdir")) {
                /* not supported: parent directory */
                return (-2);
            } else {
                /* ? */
                return (-1);
            }
        } else if (ISTREQ(fact, "UNIX.mode")) {
            if (val[0] == '0')
                sscanf(val, "%o", &mlip->mode);
            else
                sscanf(val, "%i", &mlip->mode);
            if (mlip->mode != (-1))
                mlip->mode &= 00777;
        } else if (ISTREQ(fact, "perm")) {
            STRNCPY(mlip->perm, val);
        } else if (ISTREQ(fact, "size")) {
#if defined(HAVE_LONG_LONG) && defined(SCANF_LONG_LONG)
            (void) sscanf(val, SCANF_LONG_LONG, &mlip->fsize);
#elif defined(HAVE_LONG_LONG) && defined(HAVE_STRTOQ)
            mlip->fsize = (longest_int) strtoq(val, NULL, 0);
#else
            {
                long fsize2 = 0L;
 
                (void) sscanf(val, "%ld", &fsize2);
                mlip->fsize = (longest_int) fsize2;
            }
#endif
        } else if (ISTREQ(fact, "modify")) {
            mlip->ftime = UnMDTMDate(val);
        } else if (ISTREQ(fact, "UNIX.owner")) {
            STRNCPY(mlip->owner, val);
        } else if (ISTREQ(fact, "UNIX.group")) {
            STRNCPY(mlip->group, val);
        } else if (ISTREQ(fact, "UNIX.uid")) {
            mlip->uid = atoi(val);
        } else if (ISTREQ(fact, "UNIX.gid")) {
            mlip->gid = atoi(val);
        } else if (ISTREQ(fact, "perm")) {
            STRNCPY(mlip->perm, val);
        }
 
        /* End of facts? */
        if (ec == ' ')
            break;
    }
 
    len = strlen(cp);
    if (len > (sizeof(mlip->fname) - 1)) {
        /* Filename too long */
        return (-1);
    }
    memcpy(mlip->fname, cp, len);
 
    /* also set linkto here if used */
 
    return (0);
}   /* UnMlsT */

Referenced by FTPMListOneFile(), and UnMlsD().

◆ UnvectorizeFileInfoList()

void UnvectorizeFileInfoList ( FileInfoListPtr list )

Definition at line 441 of file linelist.c.

{
    FileInfoVec fiv;
    FileInfoPtr fip;
    int i, n;
 
    fiv = list->vec;
    if (fiv != (FileInfoVec) 0) {
        list->first = fiv[0];
        n = list->nFileInfos;
        if (n > 0) {
            list->last = fiv[n - 1];
            fip = fiv[0];
            fip->prev = NULL;
            fip->next = fiv[1];
            for (i = 1; i < n; i++) {
                fip = fiv[i];
                fip->prev = fiv[i - 1];
                fip->next = fiv[i + 1];
            }
        }
        free(fiv);
        list->vec = (FileInfoVec) 0;
    }
}   /* UnvectorizeFileInfoList */

◆ URLCopyToken()

void URLCopyToken	(	char *	dst,
		size_t	dsize,
		const char *	src,
		size_t	howmuch
	)

Definition at line 598 of file open.c.

{
    char *dlim;
    const char *slim;
    unsigned int hc;
    int c;
    char h[4];
 
    dlim = dst + dsize - 1;     /* leave room for \0 */
    slim = src + howmuch;
    while (src < slim) {
        c = *src++;
        if (c == '\0')
            break;
        if (c == '%') {
            /* hex representation */
            if (src < slim + 2) {
                h[0] = *src++;
                h[1] = *src++;
                h[2] = '\0';
                hc = 0xeeff;
                if ((sscanf(h, "%x", &hc) >= 0) && (hc != 0xeeff)) {
                    if (dst < dlim) {
                        *(unsigned char *)dst = (unsigned char) hc;
                        dst++;
                    }
                }
            } else {
                break;
            }
        } else {
            *dst++ = (char) c;
        }
    }
    *dst = '\0';
}   /* URLCopyToken */

Referenced by FTPDecodeURL().

◆ VectorizeFileInfoList()

void VectorizeFileInfoList ( FileInfoListPtr list )

Definition at line 423 of file linelist.c.

{
    FileInfoVec fiv;
    FileInfoPtr fip;
    int i;
 
    fiv = (FileInfoVec) calloc((size_t) (list->nFileInfos + 1), sizeof(FileInfoPtr));
    if (fiv != (FileInfoVec) 0) {
        for (i = 0, fip = list->first; fip != NULL; fip = fip->next, i++)
            fiv[i] = fip;
        list->vec = fiv;
    }
}   /* VectorizeFileInfoList */

Referenced by Ls().

◆ WaitResponse()

int WaitResponse	(	const	FTPCIPtr,
		unsigned int	sec
	)

Definition at line 684 of file rcmd.c.

{
    int result;
    fd_set ss;
    struct timeval tv;
    int fd;
 
#ifdef NO_SIGNALS
    fd = cip->ctrlSocketR;
#else   /* NO_SIGNALS */
    if (cip->cin == NULL)
        return (-1);
    fd = fileno(cip->cin);
#endif  /* NO_SIGNALS */
    if (fd < 0)
        return (-1);
    FD_ZERO(&ss);
    FD_SET(fd, &ss);
    tv.tv_sec = (unsigned long) sec;
    tv.tv_usec = 0;
    result = select(fd + 1, SELECT_TYPE_ARG234 &ss, NULL, NULL, &tv);
    return (result);
}   /* WaitResponse */

Referenced by FTPAbortDataTransfer().

Variable Documentation

◆ gLibNcFTP_Uses_Me_To_Quiet_Variable_Unused_Warnings

int gLibNcFTP_Uses_Me_To_Quiet_Variable_Unused_Warnings

extern

Definition at line 111 of file errno.c.

◆ gLibNcFTPVersion

char gLibNcFTPVersion[64]

extern

Definition at line 11 of file ftp.c.

Referenced by OpenControlConnection(), OpenTrace(), Usage(), and VersionCmd().

Classes

Macros

Typedefs

Functions

Variables

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

◆ kDefaultFTPBufSize

◆ kDefaultFTPPort

◆ kDefaultMaxDials

◆ kDefaultRedialDelay

◆ kDefaultXferTimeout

◆ kDeleteNo

◆ kDeleteYes

◆ kFallBackToSendPortMode

◆ kFirewallFwuAtSiteFwpUserPass

◆ kFirewallLastType

◆ kFirewallLoginThenUserAtSite

◆ kFirewallNotInUse

◆ kFirewallOpenSite

◆ kFirewallSiteSite

◆ kFirewallUserAtSite

◆ kFirewallUserAtSiteFwuPassFwp

◆ kFirewallUserAtUserPassAtPass

◆ kFtwDir

◆ kFtwFile

◆ kGlobChars

◆ kGlobNo

◆ kGlobYes

◆ kLibraryMagic

◆ kLibraryVersion

◆ kMalformedURL

◆ kMlsOptModify

◆ kMlsOptPerm

◆ kMlsOptSize

◆ kMlsOptType

◆ kMlsOptUnique

◆ kMlsOptUNIXgid

◆ kMlsOptUNIXgroup

◆ kMlsOptUNIXmode

◆ kMlsOptUNIXowner

◆ kMlsOptUNIXuid

◆ kModTimeUnknown

◆ kNetReading

◆ kNetWriting

◆ kNotURL

◆ kPassiveMode

◆ kPreferredMlsOpts

◆ kPrEndMsg

◆ kPrInitMsg

◆ kPrUpdateMsg

◆ kRecursiveNo