The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 /*

  * Test: sendzlf.c 

  *

  * Description: send a zero-length file with PR_SendFile and

  * PR_TransmitFile.

  */

 #define ZERO_LEN_FILE_NAME "zerolen.tmp"

 #define HEADER_STR "Header"

 #define HEADER_LEN 6 /* length of HEADER_STR, not counting the null byte */

 #define TRAILER_STR "Trailer"

 #define TRAILER_LEN 7 /* length of TRAILER_STR, not counting the null byte */

 #include "nspr.h"

 #include <stdio.h>

 #include <stdlib.h>

 #include <string.h>

 static void ClientThread(void *arg)

 {

     PRFileDesc *sock;

     PRNetAddr addr;

     PRUint16 port = (PRUint16) arg;

     char buf[1024];

     char *bufPtr;

     PRInt32 nbytes;

     PRInt32 ntotal;

     PRInt32 nexpected;

     sock = PR_NewTCPSocket();

     if (NULL == sock) {

         fprintf(stderr, "PR_NewTCPSocket failed\n");

         exit(1);

     }

     if (PR_InitializeNetAddr(PR_IpAddrLoopback, port, &addr) == PR_FAILURE) {

         fprintf(stderr, "PR_InitializeNetAddr failed\n");

         exit(1);

     }

     if (PR_Connect(sock, &addr, PR_INTERVAL_NO_TIMEOUT) == PR_FAILURE) {

         fprintf(stderr, "PR_Connect failed\n");

         exit(1);

     }

     ntotal = 0;

     bufPtr = buf;

     while ((nbytes = PR_Read(sock, bufPtr, sizeof(buf)-ntotal)) > 0) {

         ntotal += nbytes;

         bufPtr += nbytes;

     }

     if (-1 == nbytes) {

         fprintf(stderr, "PR_Read failed\n");

         exit(1);

     }

     nexpected = HEADER_LEN+TRAILER_LEN+TRAILER_LEN+HEADER_LEN+HEADER_LEN;

     if (ntotal != nexpected) {

         fprintf(stderr, "total bytes read should be %d but is %d\n",

                 nexpected, ntotal);

         exit(1);

     }

     if (memcmp(buf, HEADER_STR TRAILER_STR TRAILER_STR HEADER_STR HEADER_STR,

             nexpected) != 0) {

         fprintf(stderr, "wrong data is received\n");

         exit(1);

     }

     if (PR_Close(sock) == PR_FAILURE) {

         fprintf(stderr, "PR_Close failed\n");

         exit(1);

     }

 }

 static void ServerThread(void *arg)

 {

     PRFileDesc *listenSock = (PRFileDesc *) arg;

     PRFileDesc *acceptSock;

     PRFileDesc *file;

     PRSendFileData sfd;

     char header[1024], trailer[1024];

     PRInt32 nbytes;

     /* Create a zero-length file */

     file = PR_Open(ZERO_LEN_FILE_NAME,

             PR_CREATE_FILE|PR_TRUNCATE|PR_RDWR, 0666);

     if (NULL == file) {

         fprintf(stderr, "PR_Open failed\n");

         exit(1);

     }

     sfd.fd = file;

     sfd.file_offset = 0;

     sfd.file_nbytes = 0;

     memcpy(header, HEADER_STR, HEADER_LEN);

     memcpy(trailer, TRAILER_STR, TRAILER_LEN);

     sfd.header = header;

     sfd.hlen = HEADER_LEN;

     sfd.trailer = trailer;

     sfd.tlen = TRAILER_LEN;

     acceptSock = PR_Accept(listenSock, NULL, PR_INTERVAL_NO_TIMEOUT);

     if (NULL == acceptSock) {

         fprintf(stderr, "PR_Accept failed\n");

         exit(1);

     }

     /* Send both header and trailer */

     nbytes = PR_SendFile(acceptSock, &sfd, PR_TRANSMITFILE_KEEP_OPEN,

             PR_INTERVAL_NO_TIMEOUT);

     if (HEADER_LEN+TRAILER_LEN != nbytes) {

         fprintf(stderr, "PR_SendFile should return %d but returned %d\n",

                 HEADER_LEN+TRAILER_LEN, nbytes);

         exit(1);

     }

     /* Trailer only, no header */

     sfd.hlen = 0;

     nbytes = PR_SendFile(acceptSock, &sfd, PR_TRANSMITFILE_KEEP_OPEN,

             PR_INTERVAL_NO_TIMEOUT);

     if (TRAILER_LEN != nbytes) {

         fprintf(stderr, "PR_SendFile should return %d but returned %d\n",

                 TRAILER_LEN, nbytes);

         exit(1);

     }

     /* Header only, no trailer */

     sfd.hlen = HEADER_LEN;

     sfd.tlen = 0;

     nbytes = PR_SendFile(acceptSock, &sfd, PR_TRANSMITFILE_KEEP_OPEN,

             PR_INTERVAL_NO_TIMEOUT);

     if (HEADER_LEN != nbytes) {

         fprintf(stderr, "PR_SendFile should return %d but returned %d\n",

                 HEADER_LEN, nbytes);

         exit(1);

     }

     /* Try PR_TransmitFile */

     nbytes = PR_TransmitFile(acceptSock, file, header, HEADER_LEN,

             PR_TRANSMITFILE_KEEP_OPEN, PR_INTERVAL_NO_TIMEOUT);

     if (HEADER_LEN != nbytes) {

         fprintf(stderr, "PR_TransmitFile should return %d but returned %d\n",

                 HEADER_LEN, nbytes);

         exit(1);

     }

     if (PR_Close(acceptSock) == PR_FAILURE) {

         fprintf(stderr, "PR_Close failed\n");

         exit(1);

     }

     if (PR_Close(file) == PR_FAILURE) {

         fprintf(stderr, "PR_Close failed\n");

         exit(1);

     }

     if (PR_Delete(ZERO_LEN_FILE_NAME) == PR_FAILURE) {

         fprintf(stderr, "PR_Delete failed\n");

         exit(1);

     }

 }

 int main(int argc, char **argv)

 {

     PRFileDesc *listenSock;

     PRThread *clientThread;

     PRThread *serverThread;

     PRNetAddr addr;

     PRThreadScope scope = PR_GLOBAL_THREAD;

     listenSock = PR_NewTCPSocket();

     if (NULL == listenSock) {

         fprintf(stderr, "PR_NewTCPSocket failed\n");

         exit(1);

     }

     if (PR_InitializeNetAddr(PR_IpAddrAny, 0, &addr) == PR_FAILURE) {

         fprintf(stderr, "PR_InitializeNetAddr failed\n");

         exit(1);

     }

     if (PR_Bind(listenSock, &addr) == PR_FAILURE) {

         fprintf(stderr, "PR_Bind failed\n");

         exit(1);

     }

     /* Find out what port number we are bound to. */

     if (PR_GetSockName(listenSock, &addr) == PR_FAILURE) {

         fprintf(stderr, "PR_GetSockName failed\n");

         exit(1);

     }

     if (PR_Listen(listenSock, 5) == PR_FAILURE) {

         fprintf(stderr, "PR_Listen failed\n");

         exit(1);

     }

     clientThread = PR_CreateThread(PR_USER_THREAD,

             ClientThread, (void *) PR_ntohs(PR_NetAddrInetPort(&addr)),

             PR_PRIORITY_NORMAL, scope, PR_JOINABLE_THREAD, 0);

     if (NULL == clientThread) {

         fprintf(stderr, "PR_CreateThread failed\n");

         exit(1);

     }

     serverThread = PR_CreateThread(PR_USER_THREAD,

             ServerThread, listenSock,

             PR_PRIORITY_NORMAL, scope, PR_JOINABLE_THREAD, 0);

     if (NULL == serverThread) {

         fprintf(stderr, "PR_CreateThread failed\n");

         exit(1);

     }

     if (PR_JoinThread(clientThread) == PR_FAILURE) {

         fprintf(stderr, "PR_JoinThread failed\n");

         exit(1);

     }

     if (PR_JoinThread(serverThread) == PR_FAILURE) {

         fprintf(stderr, "PR_JoinThread failed\n");

         exit(1);

     }

     if (PR_Close(listenSock) == PR_FAILURE) {

         fprintf(stderr, "PR_Close failed\n");

         exit(1);

     }

     printf("PASS\n");

     return 0;

 }