Unmaintained example code is probably worse than useless.
authorMichael Brown <mcb30@etherboot.org>
Mon, 15 Jan 2007 09:06:12 +0000 (09:06 +0000)
committerMichael Brown <mcb30@etherboot.org>
Mon, 15 Jan 2007 09:06:12 +0000 (09:06 +0000)
src/include/gpxe/hello.h [deleted file]
src/net/tcp/hello.c [deleted file]

diff --git a/src/include/gpxe/hello.h b/src/include/gpxe/hello.h
deleted file mode 100644 (file)
index 31e035c..0000000
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef _GPXE_HELLO_H
-#define _GPXE_HELLO_H
-
-/** @file
- *
- * "Hello world" TCP protocol
- *
- */
-
-#include <stdint.h>
-#include <gpxe/tcp.h>
-#include <gpxe/async.h>
-
-enum hello_state {
-       HELLO_SENDING_MESSAGE = 1,
-       HELLO_SENDING_ENDL,
-};
-
-/**
- * A "hello world" request
- *
- */
-struct hello_request {
-       /** Server to connect to */
-       struct sockaddr_tcpip server;
-       /** Message to be transmitted */
-       const char *message;
-       /** Callback function
-        *
-        * @v data      Received data
-        * @v len       Length of received data
-        *
-        * This function is called for all data received from the
-        * remote server.
-        */
-       void ( *callback ) ( char *data, size_t len );
-
-       /** Current state */
-       enum hello_state state;
-       /** Amount of message remaining to be transmitted */
-       size_t remaining;
-
-       /** TCP application for this request */
-       struct tcp_application tcp;
-
-       /** Asynchronous operation */
-       struct async async;
-};
-
-extern struct async_operation * say_hello ( struct hello_request *hello );
-
-#endif
diff --git a/src/net/tcp/hello.c b/src/net/tcp/hello.c
deleted file mode 100644 (file)
index 25c0793..0000000
+++ /dev/null
@@ -1,122 +0,0 @@
-#include <stddef.h>
-#include <string.h>
-#include <vsprintf.h>
-#include <assert.h>
-#include <gpxe/async.h>
-#include <gpxe/hello.h>
-
-/** @file
- *
- * "Hello world" TCP protocol
- *
- * This file implements a trivial TCP-based protocol.  It connects to
- * the server specified in hello_request::server and transmits a
- * single message (hello_request::message).  Any data received from
- * the server will be passed to the callback function,
- * hello_request::callback(), and once the connection has been closed,
- * the asynchronous operation associated with the request will be
- * marked as complete.
- *
- * To use this code, do something like:
- *
- * @code
- *
- *   static void my_callback ( char *data, size_t len ) {
- *     ... process data ...
- *   }
- *
- *   struct hello_request hello = {
- *     .server = {
- *       ...
- *     },
- *     .message = "hello world!",
- *     .callback = my_callback,
- *   };
- *
- *   rc = async_wait ( say_hello ( &hello ) );
- *
- * @endcode
- *
- * It's worth noting that this trivial protocol would be entirely
- * adequate to implement a TCP-based version of TFTP; just use "RRQ
- * <filename>" as the message.  Now, if only an appropriate server
- * existed...
- */
-
-static inline struct hello_request *
-tcp_to_hello ( struct tcp_application *app ) {
-       return container_of ( app, struct hello_request, tcp );
-}
-
-static void hello_closed ( struct tcp_application *app, int status ) {
-       struct hello_request *hello = tcp_to_hello ( app );
-
-       async_done ( &hello->async, status );
-}
-
-static void hello_connected ( struct tcp_application *app ) {
-       struct hello_request *hello = tcp_to_hello ( app );
-
-       hello->remaining = strlen ( hello->message );
-       hello->state = HELLO_SENDING_MESSAGE;
-}
-
-static void hello_acked ( struct tcp_application *app, size_t len ) {
-       struct hello_request *hello = tcp_to_hello ( app );
-       
-       hello->message += len;
-       hello->remaining -= len;
-       if ( hello->remaining == 0 ) {
-               switch ( hello->state ) {
-               case HELLO_SENDING_MESSAGE:
-                       hello->message = "\r\n";
-                       hello->remaining = 2;
-                       hello->state = HELLO_SENDING_ENDL;
-                       break;
-               case HELLO_SENDING_ENDL:
-                       /* Nothing to do once we've finished sending
-                        * the end-of-line indicator.
-                        */
-                       break;
-               default:
-                       assert ( 0 );
-               }
-       }
-}
-
-static void hello_newdata ( struct tcp_application *app, void *data,
-                           size_t len ) {
-       struct hello_request *hello = tcp_to_hello ( app );
-
-       hello->callback ( data, len );
-}
-
-static void hello_senddata ( struct tcp_application *app,
-                            void *buf __unused, size_t len __unused ) {
-       struct hello_request *hello = tcp_to_hello ( app );
-
-       tcp_send ( app, hello->message, hello->remaining );
-}
-
-static struct tcp_operations hello_tcp_operations = {
-       .closed         = hello_closed,
-       .connected      = hello_connected,
-       .acked          = hello_acked,
-       .newdata        = hello_newdata,
-       .senddata       = hello_senddata,
-};
-
-/**
- * Initiate a "hello world" connection
- *
- * @v hello    "Hello world" request
- */
-struct async_operation * say_hello ( struct hello_request *hello ) {
-       int rc;
-
-       hello->tcp.tcp_op = &hello_tcp_operations;
-       if ( ( rc = tcp_connect ( &hello->tcp, &hello->server, 0 ) ) != 0 )
-               async_done ( &hello->async, rc );
-
-       return &hello->async;
-}