ftplib.c

在SYMBIAN平台上用OPEN C实现的一个FTP客户程序

    {
	return 0;
    }
    if (nData->buf)
    {
        i = readline(buf, max, nData);
    }
    else
    {
        i = socket_wait(nData);
	if (i != 1)
	{
	    return 0;
	}
        i = net_read(nData->handle, buf, max);
    }
    if (i == -1)
    {
	return 0;
    }
    nData->xfered += i;
    if (nData->idlecb && nData->cbbytes)
    {
        nData->xfered1 += i;
        if (nData->xfered1 > nData->cbbytes)
        {
	    if (nData->idlecb(nData, nData->xfered, nData->idlearg) == 0)
	    {
		return 0;
	    }
            nData->xfered1 = 0;
        }
    }
    return i;
}

/*
 * FtpWrite - write to a data connection
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpWrite(void *buf, int len, netbuf *nData)
int FtpWrite(void *buf, int len, netbuf *nData)
{
    int i;
    if (nData->dir != FTPLIB_WRITE)
	return 0;
    if (nData->buf)
    	i = writeline(buf, len, nData);
    else
    {
        socket_wait(nData);
        i = net_write(nData->handle, buf, len);
    }
    if (i == -1)
	return 0;
    nData->xfered += i;
    if (nData->idlecb && nData->cbbytes)
    {
        nData->xfered1 += i;
        if (nData->xfered1 > nData->cbbytes)
        {
            nData->idlecb(nData, nData->xfered, nData->idlearg);
            nData->xfered1 = 0;
        }
    }
    return i;
}

/*
 * FtpClose - close a data connection
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpClose(netbuf *nData)
int FtpClose(netbuf *nData)
{
    netbuf *ctrl;
    switch (nData->dir)
    {
      case FTPLIB_WRITE:
	/* potential problem - if buffer flush fails, how to notify user? */
	if (nData->buf != NULL)
	    writeline(NULL, 0, nData);
      case FTPLIB_READ:
	if (nData->buf)
	    free(nData->buf);
	shutdown(nData->handle,2);
	net_close(nData->handle);
	ctrl = nData->ctrl;
	free(nData);
	if (ctrl)
	{
	    ctrl->data = NULL;
	    return(readresp('2', ctrl));
	}
	return 1;
      case FTPLIB_CONTROL:
	if (nData->data)
	{
	    nData->ctrl = NULL;
	    FtpClose(nData);
	}
	net_close(nData->handle);
	free(nData);
	return 0;
    }
    return 1;
}

/*
 * FtpSite - send a SITE command
 *
 * return 1 if command successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpSite(const char *cmd, netbuf *nControl)
int FtpSite(const char *cmd, netbuf *nControl)
{
    char buf[256];
    
    if ((strlen(cmd) + 7) > sizeof(buf))
        return 0;
    sprintf(buf,"SITE %s",cmd);
    if (!FtpSendCmd(buf,'2',nControl))
	return 0;
    return 1;
}

/*
 * FtpSysType - send a SYST command
 *
 * Fills in the user buffer with the remote system type.  If more
 * information from the response is required, the user can parse
 * it out of the response buffer returned by FtpLastResponse().
 *
 * return 1 if command successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpSysType(char *buf, int max, netbuf *nControl)
int FtpSysType(char *buf, int max, netbuf *nControl)
{
    int l = max;
    char *b = buf;
    char *s;
    if (!FtpSendCmd("SYST",'2',nControl))
	return 0;
    s = &nControl->response[4];
    while ((--l) && (*s != ' '))
	*b++ = *s++;
    *b++ = '\0';
    return 1;
}

/*
 * FtpMkdir - create a directory at server
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpMkdir(const char *path, netbuf *nControl)
int FtpMkdir(const char *path, netbuf *nControl)
{
    char buf[256];

    if ((strlen(path) + 6) > sizeof(buf))
        return 0;
    sprintf(buf,"MKD %s",path);
    if (!FtpSendCmd(buf,'2', nControl))
	return 0;
    return 1;
}

/*
 * FtpChdir - change path at remote
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpChdir(const char *path, netbuf *nControl)
int FtpChdir(const char *path, netbuf *nControl)
{
    char buf[256];

    if ((strlen(path) + 6) > sizeof(buf))
        return 0;
    sprintf(buf,"CWD %s",path);
    if (!FtpSendCmd(buf,'2',nControl))
	return 0;
    return 1;
}

/*
 * FtpCDUp - move to parent directory at remote
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpCDUp(netbuf *nControl)
int FtpCDUp(netbuf *nControl)
{
    if (!FtpSendCmd("CDUP",'2',nControl))
	return 0;
    return 1;
}

/*
 * FtpRmdir - remove directory at remote
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpRmdir(const char *path, netbuf *nControl)
int FtpRmdir(const char *path, netbuf *nControl)
{
    char buf[256];

    if ((strlen(path) + 6) > sizeof(buf))
        return 0;
    sprintf(buf,"RMD %s",path);
    if (!FtpSendCmd(buf,'2',nControl))
	return 0;
    return 1;
}

/*
 * FtpPwd - get working directory at remote
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpPwd(char *path, int max, netbuf *nControl)
int FtpPwd(char *path, int max, netbuf *nControl)
{
    int l = max;
    char *b = path;
    char *s;
    if (!FtpSendCmd("PWD",'2',nControl))
	return 0;
    s = strchr(nControl->response, '"');
    if (s == NULL)
	return 0;
    s++;
    while ((--l) && (*s) && (*s != '"'))
	*b++ = *s++;
    *b++ = '\0';
    return 1;
}

/*
 * FtpXfer - issue a command and transfer data
 *
 * return 1 if successful, 0 otherwise
 */
static int FtpXfer(const char *localfile, const char *path,
	netbuf *nControl, int typ, int mode) 
{
    int l;
/* This original code is commented out due to the conversion changes */
//  int c;
  
    FILE *local = NULL;
    netbuf *nData;
    int rv=1;

	rvs--;

    if (localfile != NULL)
    {
	char ac[4] = "w";
	if (typ == FTPLIB_FILE_WRITE)
	    ac[0] = 'r';
	if (mode == FTPLIB_IMAGE)
	    ac[1] = 'b';
	local = fopen(localfile, ac);
	if (local == NULL)
	{
	    strncpy(nControl->response, strerror(errno),
                    sizeof(nControl->response));
	    return 0;
	}
    }
    if (local == NULL)
	local = (typ == FTPLIB_FILE_WRITE) ? stdin : stdout;
    if (!FtpAccess(path, typ, mode, nControl, &nData))
	return 0;
    dbuf = malloc(FTPLIB_BUFSIZ);
    if (typ == FTPLIB_FILE_WRITE)
    {
	while ((l = fread(dbuf, 1, FTPLIB_BUFSIZ, local)) > 0)
/* This original code is commented out due to the conversion changes */
//	    if ((c = FtpWrite(dbuf, l, nData)) < l)
	    if ((FtpWrite(dbuf, l, nData)) < l)
	    {
/* This original code is commented out due to the conversion changes */
//		printf("short write: passed %d, wrote %d\n", l, c);
		rv = 0;
		break;
	    }
    }
    else
    {
    	while ((l = FtpRead(dbuf, FTPLIB_BUFSIZ, nData)) > 0)
    	{
		rvstmp = (char *)calloc(strlen(rvs) + strlen(dbuf) + 1, sizeof(char));

		strcpy(rvstmp, rvs);
		strcat(rvstmp, dbuf);
  
		rvs = (char *)calloc(strlen(rvstmp) + 1, sizeof(char));

		strcpy(rvs, rvstmp);

	    if (fwrite(dbuf, 1, l, local) <= 0)
	    {
/* This original code is commented out due to the conversion changes */
//		perror("localfile write");
		rv = 0;
		break;
	    }
    	}
    }
    free(dbuf);
    free(rvstmp);
    fflush(local);
    if (localfile != NULL)
	fclose(local);
    FtpClose(nData);

    return rv;
}

/*
 * FtpNlst - issue an NLST command and write response to output
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpNlst(const char *outputfile, const char *path,
char* FtpNlst(const char *outputfile, const char *path,
	netbuf *nControl)
{
/* This original code is commented out due to the conversion changes */
//  return FtpXfer(outputfile, path, nControl, FTPLIB_DIR, FTPLIB_ASCII);
    FtpXfer(outputfile, path, nControl, FTPLIB_DIR, FTPLIB_ASCII);
    return rvs;
}

/*
 * FtpDir - issue a LIST command and write response to output
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpDir(const char *outputfile, const char *path, netbuf *nControl)
char* FtpDir(const char *outputfile, const char *path, netbuf *nControl)
{
/* This original code is commented out due to the conversion changes */
//  return FtpXfer(outputfile, path, nControl, FTPLIB_DIR_VERBOSE, FTPLIB_ASCII);
    FtpXfer(outputfile, path, nControl, FTPLIB_DIR_VERBOSE, FTPLIB_ASCII);
    return rvs;
}

/*
 * FtpSize - determine the size of a remote file
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpSize(const char *path, int *size, char mode, netbuf *nControl)
int FtpSize(const char *path, int *size, char mode, netbuf *nControl)
{
    char cmd[256];
    int resp,sz,rv=1;

    if ((strlen(path) + 7) > sizeof(cmd))
        return 0;
    sprintf(cmd, "TYPE %c", mode);
    if (!FtpSendCmd(cmd, '2', nControl))
	return 0;
    sprintf(cmd,"SIZE %s",path);
    if (!FtpSendCmd(cmd,'2',nControl))
	rv = 0;
    else
    {
	if (sscanf(nControl->response, "%d %d", &resp, &sz) == 2)
	    *size = sz;
	else
	    rv = 0;
    }   
    return rv;
}

/*
 * FtpModDate - determine the modification date of a remote file
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpModDate(const char *path, char *dt, int max, netbuf *nControl)
int FtpModDate(const char *path, char *dt, int max, netbuf *nControl)
{
    char buf[256];
    int rv = 1;

    if ((strlen(path) + 7) > sizeof(buf))
        return 0;
    sprintf(buf,"MDTM %s",path);
    if (!FtpSendCmd(buf,'2',nControl))
	rv = 0;
    else
	strncpy(dt, &nControl->response[4], max);
    return rv;
}

/*
 * FtpGet - issue a GET command and write received data to output
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpGet(const char *outputfile, const char *path,
char* FtpGet(const char *outputfile, const char *path,
	char mode, netbuf *nControl)
{
/* This original code is commented out due to the conversion changes */
//  return FtpXfer(outputfile, path, nControl, FTPLIB_FILE_READ, mode);
    FtpXfer(outputfile, path, nControl, FTPLIB_FILE_READ, mode);
    return rvs;
}

/*
 * FtpPut - issue a PUT command and send data from input
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpPut(const char *inputfile, const char *path, char mode,
char* FtpPut(const char *inputfile, const char *path, char mode,
	netbuf *nControl)
{
/* This original code is commented out due to the conversion changes */
//  return FtpXfer(inputfile, path, nControl, FTPLIB_FILE_WRITE, mode);
    FtpXfer(inputfile, path, nControl, FTPLIB_FILE_WRITE, mode);
    return rvs;
}

/*
 * FtpRename - rename a file at remote
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpRename(const char *src, const char *dst, netbuf *nControl)
int FtpRename(const char *src, const char *dst, netbuf *nControl)
{
    char cmd[256];

    if (((strlen(src) + 7) > sizeof(cmd)) ||
        ((strlen(dst) + 7) > sizeof(cmd)))
        return 0;
    sprintf(cmd,"RNFR %s",src);
    if (!FtpSendCmd(cmd,'3',nControl))
	return 0;
    sprintf(cmd,"RNTO %s",dst);
    if (!FtpSendCmd(cmd,'2',nControl))
	return 0;
    return 1;
}

/*
 * FtpDelete - delete a file at remote
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF int FtpDelete(const char *fnm, netbuf *nControl)
char* FtpDelete(const char *fnm, netbuf *nControl)
{
    char cmd[256];

    if ((strlen(fnm) + 7) > sizeof(cmd))
        return 0;
    sprintf(cmd,"DELE %s",fnm);
    if (!FtpSendCmd(cmd,'2', nControl))
	return "0";
    return "1";
}

/*
 * FtpQuit - disconnect from remote
 *
 * return 1 if successful, 0 otherwise
 */
/* This original code is commented out due to the conversion changes */
//GLOBALDEF void FtpQuit(netbuf *nControl)
void FtpQuit(netbuf *nControl)
{
    if (nControl->dir != FTPLIB_CONTROL)
	return;
    FtpSendCmd("QUIT",'2',nControl);
    net_close(nControl->handle);
    free(nControl->buf);
    free(nControl);
}