auto import from //depot/cupcake/@135843

1 files changed, 201 insertions, 0 deletions

diff --git a/proxy/proxy_int.h b/proxy/proxy_int.h
new file mode 100644
index 0000000..739bb75
--- /dev/null
+++ b/proxy/proxy_int.h
@@ -0,0 +1,201 @@
+/* Copyright (C) 2007-2008 The Android Open Source Project
+**
+** This software is licensed under the terms of the GNU General Public
+** License version 2, as published by the Free Software Foundation, and
+** may be copied, distributed, and modified under those terms.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+*/
+#ifndef _PROXY_INT_H
+#define _PROXY_INT_H
+
+#include "proxy_common.h"
+#include "sockets.h"
+#include "android/utils/stralloc.h"
+
+extern int  proxy_log;
+
+extern void
+proxy_LOG(const char*  fmt, ...);
+
+#define  PROXY_LOG(...)   \
+    do { if (proxy_log) proxy_LOG(__VA_ARGS__); } while (0)
+
+
+/* ProxySelect is used to handle events */
+
+enum {
+    PROXY_SELECT_READ  = (1 << 0),
+    PROXY_SELECT_WRITE = (1 << 1),
+    PROXY_SELECT_ERROR = (1 << 2)
+};
+
+typedef struct {
+    int*     pcount;
+    fd_set*  reads;
+    fd_set*  writes;
+    fd_set*  errors;
+} ProxySelect;
+
+extern void     proxy_select_set( ProxySelect*  sel,
+                                  int           fd,
+                                  unsigned      flags );
+
+extern unsigned  proxy_select_poll( ProxySelect*  sel, int  fd );
+
+
+/* sockets proxy manager internals */
+
+typedef struct ProxyConnection   ProxyConnection;
+typedef struct ProxyService      ProxyService;
+
+/* free a given proxified connection */
+typedef void              (*ProxyConnectionFreeFunc)   ( ProxyConnection*  conn );
+
+/* modify the ProxySelect to tell which events to listen to */
+typedef void              (*ProxyConnectionSelectFunc) ( ProxyConnection*  conn,
+                                                         ProxySelect*      sel );
+
+/* action a proxy connection when select() returns certain events for its socket */
+typedef void              (*ProxyConnectionPollFunc)   ( ProxyConnection*  conn,
+                                                         ProxySelect*      sel );
+
+
+/* root ProxyConnection object */
+struct ProxyConnection {
+    int                 socket;
+    SockAddress         address;  /* for debugging */
+    ProxyConnection*    next;
+    ProxyConnection*    prev;
+    ProxyEventFunc      ev_func;
+    void*               ev_opaque;
+    ProxyService*       service;
+
+    /* the following is useful for all types of services */
+    char                name[64];    /* for debugging purposes */
+
+    stralloc_t          str[1];      /* network buffer (dynamic) */
+    int                 str_pos;     /* see proxy_connection_send() */
+    int                 str_sent;    /* see proxy_connection_send() */
+    int                 str_recv;    /* see proxy_connection_receive() */
+
+    /* connection methods */
+    ProxyConnectionFreeFunc    conn_free;
+    ProxyConnectionSelectFunc  conn_select;
+    ProxyConnectionPollFunc    conn_poll;
+
+    /* rest of data depend on exact implementation */
+};
+
+
+
+extern void
+proxy_connection_init( ProxyConnection*           conn,
+                       int                        socket,
+                       SockAddress*               address,
+                       ProxyService*              service,
+                       ProxyConnectionFreeFunc    conn_free,
+                       ProxyConnectionSelectFunc  conn_select,
+                       ProxyConnectionPollFunc    conn_poll );
+
+extern void
+proxy_connection_done( ProxyConnection*  conn );
+
+/* free the proxy connection object. this will also
+ * close the corresponding socket unless the 
+ * 'keep_alive' flag is set to TRUE.
+ */
+extern void
+proxy_connection_free( ProxyConnection*  conn,
+                       int               keep_alive,
+                       ProxyEvent        event );
+
+/* status of data transfer operations */
+typedef enum {
+    DATA_ERROR     = -1,
+    DATA_NEED_MORE =  0,
+    DATA_COMPLETED =  1
+} DataStatus;
+
+/* try to send data from the connection's buffer to a socket.
+ * starting from offset conn->str_pos in the buffer
+ *
+ * returns DATA_COMPLETED if everything could be written
+ * returns DATA_ERROR for a socket disconnection or error
+ * returns DATA_NEED_MORE if all data could not be sent.
+ *
+ * on exit, conn->str_sent contains the number of bytes
+ * that were really sent. conn->str_pos will be incremented
+ * by conn->str_sent as well.
+ *
+ * note that in case of success (DATA_COMPLETED), this also
+ * performs a proxy_connection_rewind which sets conn->str_pos
+ * to 0.
+ */
+extern DataStatus
+proxy_connection_send( ProxyConnection*  conn, int  fd );
+
+/* try to read 'wanted' bytes into conn->str from a socket
+ *
+ * returns DATA_COMPLETED if all bytes could be read
+ * returns DATA_NEED_MORE if not all bytes could be read
+ * returns DATA_ERROR in case of socket disconnection or error
+ *
+ * on exit, the amount of data received is in conn->str_recv
+ */
+extern DataStatus
+proxy_connection_receive( ProxyConnection*  conn, int  fd, int  wanted );
+
+/* tries to receive a line of text from the proxy.
+ * when an entire line is read, the trailing \r\n is stripped
+ * and replaced by a terminating zero. str->n will be the
+ * lenght of the line, exclusing the terminating zero.
+ * returns 1 when a line has been received
+ * returns 0 if there is still some data to receive
+ * returns -1 in case of error
+ */
+extern DataStatus
+proxy_connection_receive_line( ProxyConnection*  conn, int  fd );
+
+/* rewind the string buffer for a new operation */
+extern void
+proxy_connection_rewind( ProxyConnection*  conn );
+
+/* base64 encode a source string, returns size of encoded result,
+ * or -1 if there was not enough room in the destination buffer
+ */
+extern int
+proxy_base64_encode( const char*  src, int  srclen,
+                     char*        dst, int  dstlen );
+
+extern int
+proxy_resolve_server( SockAddress*   addr,
+                      const char*    servername,
+                      int            servernamelen,
+                      int            serverport );
+
+/* a ProxyService is really a proxy server and associated options */
+
+/* destroy a given proxy service */
+typedef void              (*ProxyServiceFreeFunc)      ( void*  opaque );
+
+/* tries to create a new proxified connection, returns NULL if the service can't
+ * handle this address */
+typedef ProxyConnection*  (*ProxyServiceConnectFunc)( void*               opaque,
+                                                      SocketType          socket_type,
+                                                      const SockAddress*  address );
+
+struct ProxyService {
+    void*                      opaque;
+    ProxyServiceFreeFunc       serv_free;
+    ProxyServiceConnectFunc    serv_connect;
+};
+
+extern int
+proxy_manager_add_service( ProxyService*  service );
+
+
+#endif /* _PROXY_INT_H */