| /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ |
| /* ***** BEGIN LICENSE BLOCK ***** |
| * Version: MPL 1.1/GPL 2.0/LGPL 2.1 |
| * |
| * The contents of this file are subject to the Mozilla Public License Version |
| * 1.1 (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * http://www.mozilla.org/MPL/ |
| * |
| * Software distributed under the License is distributed on an "AS IS" basis, |
| * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License |
| * for the specific language governing rights and limitations under the |
| * License. |
| * |
| * The Original Code is the Netscape Portable Runtime (NSPR). |
| * |
| * The Initial Developer of the Original Code is |
| * Netscape Communications Corporation. |
| * Portions created by the Initial Developer are Copyright (C) 1998-2000 |
| * the Initial Developer. All Rights Reserved. |
| * |
| * Contributor(s): |
| * |
| * Alternatively, the contents of this file may be used under the terms of |
| * either the GNU General Public License Version 2 or later (the "GPL"), or |
| * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), |
| * in which case the provisions of the GPL or the LGPL are applicable instead |
| * of those above. If you wish to allow use of your version of this file only |
| * under the terms of either the GPL or the LGPL, and not to allow others to |
| * use your version of this file under the terms of the MPL, indicate your |
| * decision by deleting the provisions above and replace them with the notice |
| * and other provisions required by the GPL or the LGPL. If you do not delete |
| * the provisions above, a recipient may use your version of this file under |
| * the terms of any one of the MPL, the GPL or the LGPL. |
| * |
| * ***** END LICENSE BLOCK ***** */ |
| |
| /*********************************************************************** |
| ** |
| ** Name: forktest.c |
| ** |
| ** Description: UNIX test for fork functions. |
| ** |
| ** Modification History: |
| ** 15-May-97 AGarcia- Converted the test to accomodate the debug_mode flag. |
| ** The debug mode will print all of the printfs associated with this test. |
| ** The regress mode will be the default mode. Since the regress tool limits |
| ** the output to a one line status:PASS or FAIL,all of the printf statements |
| ** have been handled with an if (debug_mode) statement. |
| ** 04-June-97 AGarcia removed the Test_Result function. Regress tool has been updated to |
| ** recognize the return code from tha main program. |
| ** 12-June-97 AGarcic - Revert to return code 0 and 1, remove debug option (obsolete). |
| ***********************************************************************/ |
| |
| /*********************************************************************** |
| ** Includes |
| ***********************************************************************/ |
| /* Used to get the command line option */ |
| #include "plgetopt.h" |
| |
| #include "nspr.h" |
| #include <string.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| |
| PRIntn failed_already=0; |
| |
| #ifdef XP_UNIX |
| |
| #include <sys/types.h> |
| #include <sys/wait.h> |
| #include <unistd.h> |
| #include <errno.h> |
| |
| static char *message = "Hello world!"; |
| |
| static void |
| ClientThreadFunc(void *arg) |
| { |
| PRNetAddr addr; |
| PRFileDesc *sock = NULL; |
| PRInt32 tmp = (PRInt32)arg; |
| |
| /* |
| * Make sure the PR_Accept call will block |
| */ |
| |
| printf("Wait one second before connect\n"); |
| fflush(stdout); |
| PR_Sleep(PR_SecondsToInterval(1)); |
| |
| addr.inet.family = AF_INET; |
| addr.inet.ip = PR_htonl(INADDR_ANY); |
| addr.inet.port = 0; |
| if ((sock = PR_NewTCPSocket()) == NULL) { |
| fprintf(stderr, "failed to create TCP socket: error code %d\n", |
| PR_GetError()); |
| failed_already = 1; |
| goto finish; |
| } |
| if (PR_Bind(sock, &addr) != PR_SUCCESS) { |
| fprintf(stderr, "PR_Bind failed: error code %d\n", |
| PR_GetError()); |
| failed_already = 1; |
| goto finish; |
| } |
| addr.inet.ip = PR_htonl(INADDR_LOOPBACK); |
| addr.inet.port = PR_htons((PRInt16)tmp); |
| printf("Connecting to port %hu\n", PR_ntohs(addr.inet.port)); |
| fflush(stdout); |
| if (PR_Connect(sock, &addr, PR_SecondsToInterval(5)) != |
| PR_SUCCESS) { |
| fprintf(stderr, "PR_Connect failed: error code %d\n", |
| PR_GetError()); |
| failed_already = 1; |
| goto finish; |
| } |
| printf("Writing message \"%s\"\n", message); |
| fflush(stdout); |
| if (PR_Send(sock, message, strlen(message) + 1, 0, PR_INTERVAL_NO_TIMEOUT) == |
| -1) { |
| fprintf(stderr, "PR_Send failed: error code %d\n", |
| PR_GetError()); |
| failed_already = 1; |
| goto finish; |
| } |
| finish: |
| if (sock) { |
| PR_Close(sock); |
| } |
| return; |
| } |
| |
| /* |
| * DoIO -- |
| * This function creates a thread that acts as a client and itself. |
| * acts as a server. Then it joins the client thread. |
| */ |
| static void |
| DoIO(void) |
| { |
| PRThread *clientThread; |
| PRFileDesc *listenSock = NULL; |
| PRFileDesc *sock = NULL; |
| PRNetAddr addr; |
| PRInt32 nBytes; |
| char buf[128]; |
| |
| listenSock = PR_NewTCPSocket(); |
| if (!listenSock) { |
| fprintf(stderr, "failed to create a TCP socket: error code %d\n", |
| PR_GetError()); |
| failed_already = 1; |
| goto finish; |
| } |
| addr.inet.family = AF_INET; |
| addr.inet.ip = PR_htonl(INADDR_ANY); |
| addr.inet.port = 0; |
| if (PR_Bind(listenSock, &addr) == PR_FAILURE) { |
| fprintf(stderr, "failed to bind socket: error code %d\n", |
| PR_GetError()); |
| failed_already = 1; |
| goto finish; |
| } |
| if (PR_GetSockName(listenSock, &addr) == PR_FAILURE) { |
| fprintf(stderr, "failed to get socket port number: error code %d\n", |
| PR_GetError()); |
| failed_already = 1; |
| goto finish; |
| } |
| if (PR_Listen(listenSock, 5) == PR_FAILURE) { |
| fprintf(stderr, "PR_Listen failed: error code %d\n", |
| PR_GetError()); |
| failed_already = 1; |
| goto finish; |
| } |
| clientThread = PR_CreateThread( PR_USER_THREAD, ClientThreadFunc, |
| (void *) PR_ntohs(addr.inet.port), PR_PRIORITY_NORMAL, PR_LOCAL_THREAD, |
| PR_JOINABLE_THREAD, 0); |
| if (clientThread == NULL) { |
| fprintf(stderr, "Cannot create client thread: (%d, %d)\n", |
| PR_GetError(), PR_GetOSError()); |
| failed_already = 1; |
| goto finish; |
| } |
| printf("Accepting connection at port %hu\n", PR_ntohs(addr.inet.port)); |
| fflush(stdout); |
| sock = PR_Accept(listenSock, &addr, PR_SecondsToInterval(5)); |
| if (!sock) { |
| fprintf(stderr, "PR_Accept failed: error code %d\n", |
| PR_GetError()); |
| failed_already = 1; |
| goto finish; |
| } |
| nBytes = PR_Recv(sock, buf, sizeof(buf), 0, PR_INTERVAL_NO_TIMEOUT); |
| if (nBytes == -1) { |
| fprintf(stderr, "PR_Recv failed: error code %d\n", |
| PR_GetError()); |
| failed_already = 1; |
| goto finish; |
| } |
| |
| /* |
| * Make sure it has proper null byte to mark end of string |
| */ |
| |
| buf[sizeof(buf) - 1] = '\0'; |
| printf("Received \"%s\" from the client\n", buf); |
| fflush(stdout); |
| if (!strcmp(buf, message)) { |
| PR_JoinThread(clientThread); |
| |
| printf("The message is received correctly\n"); |
| fflush(stdout); |
| } else { |
| fprintf(stderr, "The message should be \"%s\"\n", |
| message); |
| failed_already = 1; |
| } |
| |
| finish: |
| if (listenSock) { |
| PR_Close(listenSock); |
| } |
| if (sock) { |
| PR_Close(sock); |
| } |
| return; |
| } |
| |
| #ifdef _PR_DCETHREADS |
| |
| #include <syscall.h> |
| |
| pid_t PR_UnixFork1(void) |
| { |
| pid_t parent = getpid(); |
| int rv = syscall(SYS_fork); |
| |
| if (rv == -1) { |
| return (pid_t) -1; |
| } else { |
| /* For each process, rv is the pid of the other process */ |
| if (rv == parent) { |
| /* the child */ |
| return 0; |
| } else { |
| /* the parent */ |
| return rv; |
| } |
| } |
| } |
| |
| #elif defined(SOLARIS) |
| |
| /* |
| * It seems like that in Solaris 2.4 one must call fork1() if the |
| * the child process is going to use thread functions. Solaris 2.5 |
| * doesn't have this problem. Calling fork() also works. |
| */ |
| |
| pid_t PR_UnixFork1(void) |
| { |
| return fork1(); |
| } |
| |
| #else |
| |
| pid_t PR_UnixFork1(void) |
| { |
| return fork(); |
| } |
| |
| #endif /* PR_DCETHREADS */ |
| |
| int main(int argc, char **argv) |
| { |
| pid_t pid; |
| int rv; |
| |
| /* main test program */ |
| |
| DoIO(); |
| |
| pid = PR_UnixFork1(); |
| |
| if (pid == (pid_t) -1) { |
| fprintf(stderr, "Fork failed: errno %d\n", errno); |
| failed_already=1; |
| return 1; |
| } else if (pid > 0) { |
| int childStatus; |
| |
| printf("Fork succeeded. Parent process continues.\n"); |
| DoIO(); |
| if ((rv = waitpid(pid, &childStatus, 0)) != pid) { |
| #if defined(IRIX) && !defined(_PR_PTHREADS) |
| /* |
| * nspr may handle SIGCLD signal |
| */ |
| if ((rv < 0) && (errno == ECHILD)) { |
| } else |
| #endif |
| { |
| fprintf(stderr, "waitpid failed: %d\n", errno); |
| failed_already = 1; |
| } |
| } else if (!WIFEXITED(childStatus) |
| || WEXITSTATUS(childStatus) != 0) { |
| failed_already = 1; |
| } |
| printf("Parent process exits.\n"); |
| if (!failed_already) { |
| printf("PASSED\n"); |
| } else { |
| printf("FAILED\n"); |
| } |
| return failed_already; |
| } else { |
| #if defined(IRIX) && !defined(_PR_PTHREADS) |
| extern void _PR_IRIX_CHILD_PROCESS(void); |
| _PR_IRIX_CHILD_PROCESS(); |
| #endif |
| printf("Fork succeeded. Child process continues.\n"); |
| DoIO(); |
| printf("Child process exits.\n"); |
| return failed_already; |
| } |
| } |
| |
| #else /* XP_UNIX */ |
| |
| int main( int argc, |
| char *argv[] |
| ) |
| { |
| |
| printf("The fork test is applicable to Unix only.\n"); |
| return 0; |
| |
| } |
| |
| #endif /* XP_UNIX */ |
