diff options
author | patacongo <patacongo@42af7a65-404d-4744-a932-0658087f49c3> | 2008-07-30 00:29:11 +0000 |
---|---|---|
committer | patacongo <patacongo@42af7a65-404d-4744-a932-0658087f49c3> | 2008-07-30 00:29:11 +0000 |
commit | d5b792fdafc619122a2e5cae2e5918cc451ff84a (patch) | |
tree | dff6e171ddbfd6667a9308bb8099b12391b68fe2 /nuttx/examples/pipe | |
parent | 18161f32055969218532f2174e577e4b888b29f1 (diff) | |
download | px4-nuttx-d5b792fdafc619122a2e5cae2e5918cc451ff84a.tar.gz px4-nuttx-d5b792fdafc619122a2e5cae2e5918cc451ff84a.tar.bz2 px4-nuttx-d5b792fdafc619122a2e5cae2e5918cc451ff84a.zip |
Added redirection test
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@790 42af7a65-404d-4744-a932-0658087f49c3
Diffstat (limited to 'nuttx/examples/pipe')
-rw-r--r-- | nuttx/examples/pipe/Makefile | 2 | ||||
-rw-r--r-- | nuttx/examples/pipe/interlock_test.c | 15 | ||||
-rw-r--r-- | nuttx/examples/pipe/pipe.h | 5 | ||||
-rw-r--r-- | nuttx/examples/pipe/pipe_main.c | 193 | ||||
-rw-r--r-- | nuttx/examples/pipe/redirect_test.c | 274 |
5 files changed, 331 insertions, 158 deletions
diff --git a/nuttx/examples/pipe/Makefile b/nuttx/examples/pipe/Makefile index 202a8d248..4f61e86b8 100644 --- a/nuttx/examples/pipe/Makefile +++ b/nuttx/examples/pipe/Makefile @@ -38,7 +38,7 @@ ASRCS = AOBJS = $(ASRCS:.S=$(OBJEXT)) -CSRCS = pipe_main.c transfer_test.c interlock_test.c +CSRCS = pipe_main.c transfer_test.c interlock_test.c redirect_test.c COBJS = $(CSRCS:.c=$(OBJEXT)) SRCS = $(ASRCS) $(CSRCS) diff --git a/nuttx/examples/pipe/interlock_test.c b/nuttx/examples/pipe/interlock_test.c index 388bef100..e049a65f6 100644 --- a/nuttx/examples/pipe/interlock_test.c +++ b/nuttx/examples/pipe/interlock_test.c @@ -97,7 +97,10 @@ static void *null_writer(pthread_addr_t pvarg) /* Then close the FIFO */ printf("null_writer: Closing %s\n", FIFO_PATH2); - close(fd); + if (close(fd) != 0) + { + fprintf(stderr, "null_writer: close failed: %d\n", errno); + } sleep(5); printf("null_writer: Returning success\n"); @@ -177,7 +180,10 @@ int interlock_test(void) /* Close the file */ printf("interlock_test: Closing %s\n", FIFO_PATH2); - close(fd); + if (close(fd) != 0) + { + fprintf(stderr, "interlock_test: close failed: %d\n", errno); + } /* Wait for null_writer thread to complete */ @@ -204,7 +210,10 @@ int interlock_test(void) return 0; errout_with_file: - close(fd); + if (close(fd) != 0) + { + fprintf(stderr, "interlock_test: close failed: %d\n", errno); + } errout_with_thread: pthread_detach(writerid); pthread_cancel(writerid); diff --git a/nuttx/examples/pipe/pipe.h b/nuttx/examples/pipe/pipe.h index 9f5c8e591..2c18fd868 100644 --- a/nuttx/examples/pipe/pipe.h +++ b/nuttx/examples/pipe/pipe.h @@ -51,6 +51,10 @@ #define FIFO_PATH1 "/tmp/testfifo-1" #define FIFO_PATH2 "/tmp/testfifo-2" +#ifndef CONFIG_EXAMPLES_PIPE_STACKSIZE +# define CONFIG_EXAMPLES_PIPE_STACKSIZE 1024 +#endif + /**************************************************************************** * Public Types ****************************************************************************/ @@ -65,5 +69,6 @@ extern int transfer_test(int fdin, int fdout); extern int interlock_test(void); +extern int redirection_test(void); #endif /* __EXAMPLES_PIPE_PIPE_H */ diff --git a/nuttx/examples/pipe/pipe_main.c b/nuttx/examples/pipe/pipe_main.c index d6764c247..46b44390c 100644 --- a/nuttx/examples/pipe/pipe_main.c +++ b/nuttx/examples/pipe/pipe_main.c @@ -44,6 +44,7 @@ #include <stdio.h> #include <unistd.h> +#include <sched.h> #include <fcntl.h> #include <errno.h> @@ -66,151 +67,6 @@ ****************************************************************************/ /**************************************************************************** - * Name: null_writer - ****************************************************************************/ - -static void *null_writer(pthread_addr_t pvarg) -{ - int fd; - - /* Wait a bit */ - - printf("null_writer: started -- sleeping\n"); - sleep(5); - - /* Then open the FIFO for write access */ - - printf("null_writer: Opening FIFO for write access\n"); - fd = open(FIFO_PATH2, O_WRONLY); - if (fd < 0) - { - fprintf(stderr, "null_writer: Failed to open FIFO %s for writing, errno=%d\n", - FIFO_PATH2, errno); - return (void*)1; - } - - /* Wait a bit more */ - - printf("null_writer: Opened %s for writing -- sleeping\n", FIFO_PATH2); - sleep(5); - - /* Then close the FIFO */ - - printf("null_writer: Closing %s\n", FIFO_PATH2); - close(fd); - sleep(5); - - printf("null_writer: Returning success\n"); - return (void*)0; -} - -/**************************************************************************** - * Name: interlock_test - ****************************************************************************/ - -static int interlock_test(void) -{ - pthread_t writerid; - void *value; - char data[16]; - ssize_t nbytes; - int fd; - int ret; - - /* Create a FIFO */ - - ret = mkfifo(FIFO_PATH2, 0666); - if (ret < 0) - { - fprintf(stderr, "interlock_test: mkfifo failed with errno=%d\n", errno); - return 1; - } - - /* Start the null_writer_thread */ - - printf("interlock_test: Starting null_writer thread\n"); - ret = pthread_create(&writerid, NULL, null_writer, (pthread_addr_t)NULL); - if (ret != 0) - { - fprintf(stderr, "interlock_test: Failed to create null_writer thread, error=%d\n", ret); - ret = 2; - goto errout_with_fifo; - } - - /* Open one end of the FIFO for reading. This open call should block until the - * null_writer thread opens the other end of the FIFO for writing. - */ - - printf("interlock_test: Opening FIFO for read access\n"); - fd = open(FIFO_PATH2, O_RDONLY); - if (fd < 0) - { - fprintf(stderr, "interlock_test: Failed to open FIFO %s for reading, errno=%d\n", - FIFO_PATH2, errno); - ret = 3; - goto errout_with_thread; - } - - /* Attempt to read one byte from the FIFO. This should return end-of-file because - * the null_writer closes the FIFO without writing anything. - */ - - printf("interlock_test: Reading from %s\n", FIFO_PATH2); - nbytes = read(fd, data, 16); - if (nbytes < 0 ) - { - fprintf(stderr, "interlock_test: read failed, errno=%d\n", errno); - ret = 4; - goto errout_with_file; - } - else if (ret != 0) - { - fprintf(stderr, "interlock_test: Read %d bytes of data -- aborting: %d\n", nbytes); - ret = 5; - goto errout_with_file; - } - - /* Close the file */ - - printf("interlock_test: Closing %s\n", FIFO_PATH2); - close(fd); - - /* Wait for null_writer thread to complete */ - - printf("interlock_test: Waiting for null_writer thread\n"); - ret = pthread_join(writerid, &value); - if (ret != 0) - { - fprintf(stderr, "interlock_test: pthread_join failed, error=%d\n", ret); - ret = 6; - goto errout_with_fifo; - } - else - { - printf("interlock_test: writer returned %d\n", (int)value); - if (value != (void*)0) - { - ret = 7; - goto errout_with_fifo; - } - } - - /* unlink(FIFO_PATH2); */ - printf("interlock_test: Returning success\n"); - return 0; - -errout_with_file: - close(fd); -errout_with_thread: - pthread_detach(writerid); - pthread_cancel(writerid); -errout_with_fifo: - /* unlink(FIFO_PATH2); */ - printf("interlock_test: Returning %d\n", ret); - return ret; -} - -/**************************************************************************** * Public Functions ****************************************************************************/ @@ -233,7 +89,7 @@ int user_start(int argc, char *argv[]) /* Test FIFO logic */ - printf("user_start: Performing FIFO test\n"); + printf("\nuser_start: Performing FIFO test\n"); ret = mkfifo(FIFO_PATH1, 0666); if (ret < 0) { @@ -260,16 +116,26 @@ int user_start(int argc, char *argv[]) { fprintf(stderr, "user_start: Failed to open FIFO %s for reading, errno=%d\n", FIFO_PATH1, errno); - close(filedes[1]); + if (close(filedes[1]) != 0) + { + fprintf(stderr, "user_start: close failed: %d\n", errno); + } return 3; } /* Then perform the test using those file descriptors */ ret = transfer_test(filedes[0], filedes[1]); - close(filedes[0]); - close(filedes[1]); + if (close(filedes[0]) != 0) + { + fprintf(stderr, "user_start: close failed: %d\n", errno); + } + if (close(filedes[1]) != 0) + { + fprintf(stderr, "user_start: close failed: %d\n", errno); + } /* unlink(FIFO_PATH1); fails */ + if (ret != 0) { fprintf(stderr, "user_start: FIFO test FAILED (%d)\n", ret); @@ -279,7 +145,7 @@ int user_start(int argc, char *argv[]) /* Test PIPE logic */ - printf("user_start: Performing pipe test\n"); + printf("\nuser_start: Performing pipe test\n"); ret = pipe(filedes); if (ret < 0) { @@ -290,9 +156,15 @@ int user_start(int argc, char *argv[]) /* Then perform the test using those file descriptors */ ret = transfer_test(filedes[0], filedes[1]); - close(filedes[0]); - close(filedes[1]); - /* unlink(FIFO_PATH1); fails */ + if (close(filedes[0]) != 0) + { + fprintf(stderr, "user_start: close failed: %d\n", errno); + } + if (close(filedes[1]) != 0) + { + fprintf(stderr, "user_start: close failed: %d\n", errno); + } + if (ret != 0) { fprintf(stderr, "user_start: PIPE test FAILED (%d)\n", ret); @@ -300,7 +172,9 @@ int user_start(int argc, char *argv[]) } printf("user_start: PIPE test PASSED\n"); - /* Then perform the FIFO interlock test */ + /* Perform the FIFO interlock test */ + + printf("\nuser_start: Performing pipe interlock test\n"); ret = interlock_test(); if (ret != 0) { @@ -309,6 +183,17 @@ int user_start(int argc, char *argv[]) } printf("user_start: PIPE interlock test PASSED\n"); + /* Perform the pipe redirection test */ + + printf("\nuser_start: Performing redirection test\n"); + ret = redirection_test(); + if (ret != 0) + { + fprintf(stderr, "user_start: FIFO redirection test FAILED (%d)\n", ret); + return 7; + } + printf("user_start: PIPE redirection test PASSED\n"); + fflush(stdout); return 0; } diff --git a/nuttx/examples/pipe/redirect_test.c b/nuttx/examples/pipe/redirect_test.c new file mode 100644 index 000000000..6a1f60fab --- /dev/null +++ b/nuttx/examples/pipe/redirect_test.c @@ -0,0 +1,274 @@ +/**************************************************************************** + * examples/pipe/redirect_test.c + * + * Copyright (C) 2008 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include <nuttx/config.h> +#include <sys/types.h> + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <sched.h> +#include <errno.h> + +#include "pipe.h" + +/**************************************************************************** + * Definitions + ****************************************************************************/ + +#define READ_SIZE 37 + +/**************************************************************************** + * Private Types + ****************************************************************************/ + +/**************************************************************************** + * Private Data + ****************************************************************************/ + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: redirect_reader + ****************************************************************************/ + +static int redirect_reader(int argc, char *argv[]) +{ + char buffer[READ_SIZE]; + int fd = (int)argv[0]; + int ret; + int nbytes = 0; + + printf("redirect_reader: started with fd=%s\n", argv[1]); + + /* Convert the fd to binary */ + + fd = atoi(argv[1]); + + /* Re-direct the fd to stdin */ + + ret = dup2(fd, 0); + if (ret != 0) + { + fprintf(stderr, "redirect_reader: dup2 failed: %d\n", errno); + close(fd); + return 1; + } + + /* Close the original file descriptor */ + + ret = close(fd); + if (ret != 0) + { + fprintf(stderr, "redirect_reader: failed to close fd=%d\n", fd); + return 2; + } + + /* Then read from stdin until we hit the end of file */ + + for (;;) + { + /* Read from stdin */ + + ret = read(0, buffer, READ_SIZE); + if (ret < 0 ) + { + fprintf(stderr, "redirect_reader: read failed, errno=%d\n", errno); + return 3; + } + else if (ret == 0) + { + break; + } + nbytes += ret; + + /* Echo to stdout */ + + ret = write(1, buffer, ret); + if (ret < 0) + { + fprintf(stderr, "redirect_reader: read failed, errno=%d\n", errno); + return 4; + } + } + + printf("redirect_reader: %d bytes read\n", nbytes); + ret = close(0); + if (ret != 0) + { + fprintf(stderr, "redirect_reader: failed to close fd=%d\n", fd); + return 5; + } + printf("redirect_reader: Returning success\n"); + return 0; +} + +/**************************************************************************** + * Name: redirect_writer + ****************************************************************************/ + +static int redirect_writer(int argc, char *argv[]) +{ + int fd; + int nbytes = 0; + int ret; + + printf("redirect_writer: started with fd=%s\n", argv[1]); + + /* Convert the fd to binary */ + + fd = atoi(argv[1]); + + /* Re-direct the fd to stdout */ + + ret = dup2(fd, 1); + if (ret != 0) + { + fprintf(stderr, "redirect_writer: dup2 failed: %d\n", errno); + return 1; + } + + /* Close the original file descriptor */ + + ret = close(fd); + if (ret != 0) + { + fprintf(stderr, "redirect_reader: failed to close fd=%d\n", fd); + return 2; + } + + /* Then write a bunch of stuff to stdout */ + + nbytes += printf("\nFour score and seven years ago our fathers brought forth on this continent a new nation,\n"); + nbytes += printf("conceived in Liberty, and dedicated to the proposition that all men are created equal.\n"); + nbytes += printf("\nNow we are engaged in a great civil war, testing whether that nation, or any nation, so\n"); + nbytes += printf("conceived and so dedicated, can long endure. We are met on a great battle-field of that war.\n"); + nbytes += printf("We have come to dedicate a portion of that field, as a final resting place for those who here\n"); + nbytes += printf("gave their lives that that nation might live. It is altogether fitting and proper that we\n"); + nbytes += printf("should do this.\n"); + nbytes += printf("\nBut, in a larger sense, we can not dedicate—we can not consecrate—we can not hallow—this ground.\n"); + nbytes += printf("The brave men, living and dead, who struggled here, have consecrated it, far above our poor power\n"); + nbytes += printf("to add or detract. The world will little note, nor long remember what we say here, but it can\n"); + nbytes += printf("never forget what they did here. It is for us the living, rather, to be dedicated here to the\n"); + nbytes += printf("unfinished work which they who fought here have thus far so nobly advanced. It is rather for us to\n"); + nbytes += printf("be here dedicated to the great task remaining before us—that from these honored dead we take\n"); + nbytes += printf("increased devotion to that cause for which they gave the last full measure of devotion—that we\n"); + nbytes += printf("here highly resolve that these dead shall not have died in vain—that this nation, under God,\n"); + nbytes += printf("shall have a new birth of freedom—and that government of the people, by the people, for the\n"); + nbytes += printf("people, shall not perish from the earth.\n\n"); + printf("redirect_writer: %d bytes read\n", nbytes); + + ret = close(1); + if (ret != 0) + { + fprintf(stderr, "redirect_writer: failed to close fd=%d\n", fd); + return 3; + } + printf("redirect_writer: Returning success\n"); + return 0; +} + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: redirection_test + ****************************************************************************/ + +int redirection_test(void) +{ + const char *argv[2]; + char buffer[8]; + int readerid; + int writerid; + int filedes[2]; + int ret; + + /* Create the pipe */ + + ret = pipe(filedes); + if (ret < 0) + { + fprintf(stderr, "redirection_test: pipe failed with errno=%d\n", errno); + return 5; + } + + /* Start redirect_reader thread */ + + printf("redirection_test: Starting redirect_reader task with fd=%d\n", filedes[0]); + sprintf(buffer, "%d", filedes[0]); + argv[0] = buffer; + argv[1] = NULL; + readerid = task_create("redirect_reader", 50, CONFIG_EXAMPLES_PIPE_STACKSIZE, redirect_reader, argv); + if (readerid < 0) + { + fprintf(stderr, "redirection_test: Failed to create redirect_writer task: %d\n", errno); + return 1; + } + + /* Start redirect_writer task */ + + printf("redirection_test: Starting redirect_writer task with fd=%d\n", filedes[1]); + sprintf(buffer, "%d", filedes[1]); + argv[0] = buffer; + argv[1] = NULL; + writerid = task_create("redirect_writer", 50, CONFIG_EXAMPLES_PIPE_STACKSIZE, redirect_writer, argv); + if (writerid < 0) + { + fprintf(stderr, "redirection_test: Failed to create redirect_writer task: %d\n", errno); + ret = task_delete(readerid); + if (ret != 0) + { + fprintf(stderr, "redirection_test: Failed to delete redirect_reader task %d\n", errno); + } + return 2; + } + + /* Wait for redirect_writer thread to complete */ + + printf("redirection_test: Waiting...\n"); + sleep(10); + + printf("redirection_test: returning %d\n", ret); + return ret; +} + |