lookip: Disconnect asynchronously to avoid dead-locking watcher unregistration
[strongswan.git] / src / libstrongswan / networking / streams / stream.h
index bcf7fb4..3516d91 100644 (file)
@@ -25,6 +25,9 @@ typedef struct stream_t stream_t;
 
 #include <library.h>
 
+#include <sys/un.h>
+#include <sys/socket.h>
+
 /**
  * Constructor function prototype for stream_t.
  *
@@ -34,6 +37,22 @@ typedef struct stream_t stream_t;
 typedef stream_t*(*stream_constructor_t)(char *uri);
 
 /**
+ * Callback function prototype, called when stream is ready.
+ *
+ * It is not allowed to destroy the stream nor to call on_read()/on_write/()
+ * during the callback.
+ *
+ * As select() may return even if a read()/write() would actually block, it is
+ * recommended to use the non-blocking calls and handle return values
+ * appropriately.
+ *
+ * @param data                 data passed during callback registration
+ * @param stream               associated stream
+ * @return                             FALSE unregisters the invoked callback, TRUE keeps it
+ */
+typedef bool (*stream_cb_t)(void *data, stream_t *stream);
+
+/**
  * Abstraction of a Berkley socket using stream semantics.
  */
 struct stream_t {
@@ -52,6 +71,27 @@ struct stream_t {
        ssize_t (*read)(stream_t *this, void *buf, size_t len, bool block);
 
        /**
+        * Read data from the stream, avoiding short reads.
+        *
+        * This call is always blocking, and reads until len has been read
+        * completely. If the connection is closed before enough bytes could be
+        * returned, errno is set to ECONNRESET.
+        *
+        * @param buf           data buffer to read into
+        * @param len           number of bytes to read
+        * @return                      TRUE if len bytes read, FALSE on error
+        */
+       bool (*read_all)(stream_t *this, void *buf, size_t len);
+
+       /**
+        * Register a callback to invoke when stream has data to read.
+        *
+        * @param cb            callback function, NULL to unregister
+        * @param data          data to pass to callback
+        */
+       void (*on_read)(stream_t *this, stream_cb_t cb, void *data);
+
+       /**
         * Write data to the stream.
         *
         * If "block" is FALSE and the write would block, the function returns -1
@@ -65,22 +105,31 @@ struct stream_t {
        ssize_t (*write)(stream_t *this, void *buf, size_t len, bool block);
 
        /**
-        * printf() convenience function for this stream.
+        * Write data to the stream, avoiding short writes.
+        *
+        * This call is always blocking, and writes until len bytes has been
+        * written.
+        *
+        * @param buf           data buffer to write
+        * @param len           number of bytes to write
+        * @return                      TRUE if len bytes written, FALSE on error
+        */
+       bool (*write_all)(stream_t *this, void *buf, size_t len);
+
+       /**
+        * Register a callback to invoke when a write would not block.
         *
-        * @param format        printf format string
-        * @param ...           argument list for format string
-        * @return                      number of characters written, negative on error
+        * @param cb            callback function, NULL to unregister
+        * @param data          data to pass to callback
         */
-       int (*print)(stream_t *this, char *format, ...);
+       void (*on_write)(stream_t *this, stream_cb_t cb, void *data);
 
        /**
-        * vprintf() convenience function for this stream.
+        * Get a FILE reference for this stream.
         *
-        * @param format        printf format string
-        * @param ap            argument list for format string
-        * @return                      number of characters written, negative on error
+        * @return                      FILE*, must be fclose()d, NULL on error
         */
-       int (*vprint)(stream_t *this, char *format, va_list ap);
+       FILE* (*get_file)(stream_t *this);
 
        /**
         * Destroy a stream_t.
@@ -89,6 +138,54 @@ struct stream_t {
 };
 
 /**
+ * Create a stream for UNIX sockets.
+ *
+ * UNIX URIs start with unix://, followed by the socket path. For absolute
+ * paths, an URI looks something like:
+ *
+ *   unix:///path/to/socket
+ *
+ * @param uri          UNIX socket specific URI, must start with "unix://"
+ * @return                     stream instance, NULL on failure
+ */
+stream_t *stream_create_unix(char *uri);
+
+/**
+ * Helper function to parse a unix:// URI to a sockaddr
+ *
+ * @param uri          URI
+ * @param addr         sockaddr
+ * @return                     length of sockaddr, -1 on error
+ */
+int stream_parse_uri_unix(char *uri, struct sockaddr_un *addr);
+
+/**
+ * Create a stream for TCP sockets.
+ *
+ * TCP URIs start with tcp://, followed by a hostname (FQDN or IP), followed
+ * by a colon separated port. A full TCP uri looks something like:
+ *
+ *   tcp://srv.example.com:5555
+ *   tcp://0.0.0.0:1234
+ *   tcp://[fec2::1]:7654
+ *
+ * There is no default port, so a colon after tcp:// is mandatory.
+ *
+ * @param uri          TCP socket specific URI, must start with "tcp://"
+ * @return                     stream instance, NULL on failure
+ */
+stream_t *stream_create_tcp(char *uri);
+
+/**
+ * Helper function to parse a tcp:// URI to a sockaddr
+ *
+ * @param uri          URI
+ * @param addr         sockaddr, large enough for URI
+ * @return                     length of sockaddr, -1 on error
+ */
+int stream_parse_uri_tcp(char *uri, struct sockaddr *addr);
+
+/**
  * Create a stream from a file descriptor.
  *
  * The file descriptor MUST be a socket for non-blocking operation.