netdrv.c

VXWORKS源代码

    if (pNetDev->protocol == PROTO_FTP &&
        ftpCommand (ctrlSock, "QUIT",0,0,0,0,0,0) != FTP_COMPLETE)
        {
        NETDRV_DEBUG ("netFileExists:  error calling ftpCommand(\"QUIT\"). errno:0x%08x\n", errno,1,2,3,4,5);
        status = ERROR;
        }

    close (ctrlSock);

    KHEAP_FREE (pDirName);
    KHEAP_FREE (pFileName);

    NETDRV_DEBUG ("netFileExists:  returning (%d)\n", status,1,2,3,4,5);
    return (status);
    }

/*******************************************************************************
*
* netGet - downLoad a file from a remote machine via the network.
*
* The remote shell daemon on the machine 'host' is used to download
* the given file to the specified previously opened network file descriptor.
* The remote userId should have been set previously by a call to iam().
* If the file does not exist, the error message from the UNIX 'host'
* is printed to the VxWorks standard error file descriptor and ERROR
* is returned.
*
* RETURNS: OK or ERROR.
*/

LOCAL STATUS netGet
    (
    FAST NET_FD *pNetFd
    )
    {
    int dataSock;
    int ctrlSock;
    char buf [DATASIZE];	/* make buf the same size as NET_FD's databuf */
    FAST int nBytes = -1;
    char command[MAX_FILENAME_LENGTH];
    char buffer [MAX_FILENAME_LENGTH];
    int saveOptions;
    STATUS status = OK;
    char usr [MAX_IDENTITY_LEN];
    char passwd [MAX_IDENTITY_LEN];
    char *errMsg = "cat: read error: Is a directory";
    int errMsgLen = strlen (errMsg);

    remCurIdGet (usr, passwd);

    if (pNetFd->pNetDev->protocol == PROTO_FTP)
        {
        if (ftpXfer (pNetFd->pNetDev->host, usr, passwd, "",
                     "RETR %s", pNetFd->remDirName, pNetFd->remFileName,
                     &ctrlSock, &dataSock) == ERROR)
            {
            NETDRV_DEBUG ("netGet:  error calling ftpXfer(). errno:0x%08x\n", errno,1,2,3,4,5);
            return (ERROR);
            }
        }
    else
        {
        if (pathCat (pNetFd->remDirName, pNetFd->remFileName, buffer) == ERROR)
           {
           NETDRV_DEBUG ("netGet:  error calling pathCat(). errno:0x%08x\n", errno,1,2,3,4,5);
           return (ERROR);
           } 

        sprintf (command, "/bin/cat < %s", buffer);

        dataSock = rcmd (pNetFd->pNetDev->host, RSHD, usr,
                         usr, command, &ctrlSock);

        if (dataSock == ERROR)
            {
            NETDRV_DEBUG ("netGet:  error calling rcmd(). errno:0x%08x\n", errno,1,2,3,4,5);
            return (ERROR);
            }
        }

    /* Set file pointer to beginning of file */

    if (netSeek (pNetFd, 0) == ERROR)
        {
        if (pNetFd->pNetDev->protocol == PROTO_FTP &&
            ftpCommand (ctrlSock, "QUIT",0,0,0,0,0,0) != FTP_COMPLETE)
            {
            NETDRV_DEBUG ("netGet:  error calling ftpCommand(\"QUIT\"). errno:0x%08x\n",\
                          errno,1,2,3,4,5);
            status = ERROR;
            }

        close (dataSock);
        close (ctrlSock);
        return (ERROR);
        }

    /* set mode to write so that file can be written to,
    *  save original options so they can be restored later
    */

    saveOptions = pNetFd->options;
    pNetFd->options = O_WRONLY & pNetFd->pNetDev->fdMode;

    /* read bytes from socket and write them
     * out to file descriptor one block at a time
     */

    while ((status == OK) &&
           ((nBytes = read (dataSock, buf, sizeof (buf))) > 0))
        {
        if (netWrite (pNetFd, buf, nBytes) != nBytes)
            {
            NETDRV_DEBUG ("netGet:  error calling netWrite(). errno:0x%08x\n", \
                          errno,1,2,3,4,5);
            status = ERROR;
            }
        }

    if (nBytes < 0)   /* recv error */
            status = ERROR;

    close (dataSock);

    if (pNetFd->pNetDev->protocol == PROTO_FTP)
        {
        if (ftpReplyGet (ctrlSock, FALSE) != FTP_COMPLETE)
            {
            NETDRV_DEBUG ("netGet:  error calling ftpReplyGet(). errno:0x%08x\n", \
                          errno,1,2,3,4,5);
            status = ERROR;
            }
        }
    else
        {
        /* check control socket for error */

        if ((nBytes = fioRead (ctrlSock, buf, sizeof (buf) - 1)) > 0)
            {

            /* print error message on standard error fd */

            buf [nBytes] = EOS;	/* insure string termination */

            /* check error message indicating cat of NFS mounted directory */

            if (strncmp (buf, errMsg, errMsgLen) != 0)
                {
                NETDRV_DEBUG ("netGet: %s:%s  . errno:0x%08x\n",  
                                 pNetFd->pNetDev->host, buf, errno,1,2,3);
                /* set the task's status according to the UNIX error */
                getNetStatus (buf);

                status = ERROR;
                }
            }
    }

    if (pNetFd->pNetDev->protocol == PROTO_FTP &&
        ftpCommand (ctrlSock, "QUIT",0,0,0,0,0,0) != FTP_COMPLETE)
        {
        NETDRV_DEBUG ("netGet:  error calling ftpCommand(\"QUIT\"). errno:0x%08x\n", \
                      errno,1,2,3,4,5);
        status = ERROR;
        }

    close (ctrlSock);

    pNetFd->options = saveOptions;	/* restore original options */

    return (status);
    }

/*******************************************************************************
*
* netPut - upload a file to a remote machine via the network.
*
* The remote shell daemon on the machine 'host' is used to upload
* from the open network file descriptor to a remote file.
* The remote userId should have been set previously be a call
* to iam().  If an error occurs, the UNIX error is output to the
* VxWorks standard error fd.
*
* RETURNS: OK or ERROR.
*/

LOCAL STATUS netPut
    (
    FAST NET_FD *pNetFd
    )
    {
    int dataSock;
    int ctrlSock;
    char buf [DATASIZE];	/* make buf the same size as NET_FD's databuf */
    FAST int nBytes = -1;
    char command[MAX_FILENAME_LENGTH];
    char buffer[MAX_FILENAME_LENGTH];
    int saveOptions;
    STATUS status = OK;
    char usr [MAX_IDENTITY_LEN];
    char passwd [MAX_IDENTITY_LEN];

    remCurIdGet (usr, passwd);

    if (pNetFd->pNetDev->protocol == PROTO_FTP)
        {
        if (ftpXfer (pNetFd->pNetDev->host, usr, passwd, "",
                     "STOR %s", pNetFd->remDirName, pNetFd->remFileName,
                      &ctrlSock, &dataSock) == ERROR)
            {
            NETDRV_DEBUG ("netPut:  error calling ftpXfer()  errno:0x%08x\n", \
                          errno,1,2,3,4,5);
            return (ERROR);
            }
        }
    else
        {
        if (pathCat (pNetFd->remDirName, pNetFd->remFileName, buffer) == ERROR)
            {
            NETDRV_DEBUG ("netPut:  error calling pathCat(). errno:0x%08x\n", \
                          errno,1,2,3,4,5);
            return (ERROR);
            }

        sprintf (command, "/bin/cat > %s", buffer);

        dataSock = rcmd (pNetFd->pNetDev->host, RSHD, usr,
                         usr, command, &ctrlSock);

        if (dataSock == ERROR)
            {
            NETDRV_DEBUG ("netPut:  error calling rcmd(). errno:0x%08x\n", \
                          errno,1,2,3,4,5);
            return (ERROR);
            }
        }

    /* Set file pointer to beginning of file */

    if (netSeek (pNetFd, 0) == ERROR)
        {
        if (pNetFd->pNetDev->protocol == PROTO_FTP &&
            ftpCommand (ctrlSock, "QUIT",0,0,0,0,0,0) != FTP_COMPLETE)
            {
            NETDRV_DEBUG ("netPut: error calling ftpCommand(\"QUIT\").  errno:0x%08x\n",\
                          errno,1,2,3,4,5);
            status = ERROR;
            }

        close (dataSock);
        close (ctrlSock);
        return (ERROR);
        }

    /* set mode to write so that file can be written to,
     * save original options so they can be restored later
     */

        saveOptions = pNetFd->options;
        pNetFd->options = O_RDONLY & pNetFd->pNetDev->fdMode;

    /* Read the data from one DATABLOCK into buffer.
     *  Continue until file pointer reaches the end of file.
     */

    while (status == OK && (nBytes = netRead (pNetFd, buf, sizeof (buf))) > 0)
        {
        if (write (dataSock, buf, nBytes) != nBytes)
            {
            NETDRV_DEBUG ("netPut:  error calling write(). errno:0x%08x\n", \
                          errno,1,2,3,4,5);
            status = ERROR;
            }
        }

    if (nBytes < 0)		/* netRead error */
        {
        NETDRV_DEBUG ("netPut:  error calling netRead(). errno:0x%08x\n", 
                      errno,1,2,3,4,5);
        status = ERROR;
        }

    if (close (dataSock) == ERROR)
        {
        NETDRV_DEBUG ("netPut:  error calling close(). errno:0x%08x\n", errno,1,2,3,4,5);
        status = ERROR;
        }

    if (pNetFd->pNetDev->protocol == PROTO_FTP)
        {
        if (ftpReplyGet (ctrlSock, FALSE) != FTP_COMPLETE)
            {
            NETDRV_DEBUG ("netPut:  error calling ftpReplyGet(). errno:0x%08x\n", \
                          errno,1,2,3,4,5);
            status = ERROR;
            }
        }
    else
        {
        /* check control socket for error */

        if ((nBytes = fioRead (ctrlSock, buf, sizeof (buf) - 1)) > 0)
            {
            /* print error message */

            buf [nBytes] = EOS;	/* insure string termination */
            NETDRV_DEBUG ("netPut: %s:%s  . errno:0x%08x\n",  
                          pNetFd->pNetDev->host, buf, errno,1,2,3);
            /* set the task's status according to the UNIX error */
            getNetStatus (buf);

            NETDRV_DEBUG ("netPut:  error calling fioRead(). errno:0x%08x\n", \
                          errno,1,2,3,4,5);
            status = ERROR;
            }
        }

    if (pNetFd->pNetDev->protocol == PROTO_FTP &&
        ftpCommand (ctrlSock, "QUIT",0,0,0,0,0,0) != FTP_COMPLETE)
        {
        NETDRV_DEBUG ("netPut:  error calling ftpCommand(). errno:0x%08x\n", \
                      errno,1,2,3,4,5);
        status = ERROR;
        }

    close (ctrlSock);

    pNetFd->options = saveOptions;	/* restore original options */

    return (status);
    }

/****************************************************************************
*
* getNetStatus - set task status according to network error
*
* Compares string in buf with some known UNIX errors that can occur when
* copying files over the network.  Sets task status accordingly.
*/

LOCAL void getNetStatus
    (
    char *buf           /* buffer containing string with UNIX error */
    )
    {
    FAST char *pErr;

    pErr = (char *) index (buf, ':');

    if (pErr == NULL)
        errno = S_netDrv_UNIX_FILE_ERROR;

    else if (strcmp (pErr, ": Permission denied\n") == 0)
        errno = S_netDrv_PERMISSION_DENIED;

    else if (strcmp (pErr, ": No such file or directory\n") == 0)
        errno = S_netDrv_NO_SUCH_FILE_OR_DIR;

    else if (strcmp (pErr, ": Is a directory\n") == 0)
        errno = S_netDrv_IS_A_DIRECTORY;

    else
        errno = S_netDrv_UNIX_FILE_ERROR;
    }
/*******************************************************************************
*
* netRead - read bytes from remote file
*
* netRead reads up to the specified number of bytes from the open network
* file descriptor and puts them into a buffer.  Bytes are read starting
* from the point marked by the file pointer.  The file pointer is then
* updated to point immediately after the last character that was read.
*
* Called only by the I/O system.
*
* SIDE EFFECTS: moves file pointer
*
* RETURNS: Number of bytes read, or ERROR.
*/

LOCAL int netRead
    (
    FAST NET_FD *pNetFd,        /* pointer to open network file descriptor */
    char *buf,                  /* pointer to buffer to receive bytes   */
    FAST int maxBytes           /* max number of bytes to read into buffer */
    )
    {
    STATUS status = OK;
    FAST int byteCount = 0;	/* number of bytes read so far */

    /* check for valid maxbytes */

    if (maxBytes <= 0)
        {
        errno = S_netDrv_INVALID_NUMBER_OF_BYTES;
        return (ERROR);
        }

    /* if file opened for O_WRONLY, don't read */
    if ((pNetFd->options & pNetFd->pNetDev->fdMode) == O_WRONLY)
        {
        errno = S_netDrv_WRITE_ONLY_CANNOT_READ;
        return (ERROR);
        }