Connection

Name

Connection -- TCP Connection

Synopsis



struct      GConn;
enum        GConnStatus;
gboolean    (*GConnFunc)                    (GConn *conn,
                                             GConnStatus status,
                                             gchar *buffer,
                                             gint length,
                                             gpointer user_data);
GConn*      gnet_conn_new                   (const gchar *hostname,
                                             gint port,
                                             GConnFunc func,
                                             gpointer user_data);
GConn*      gnet_conn_new_inetaddr          (const GInetAddr *inetaddr,
                                             GConnFunc func,
                                             gpointer user_data);
void        gnet_conn_delete                (GConn *conn,
                                             gboolean delete_buffers);
void        gnet_conn_ref                   (GConn *conn);
void        gnet_conn_unref                 (GConn *conn,
                                             gboolean delete_buffers);
void        gnet_conn_connect               (GConn *conn,
                                             guint timeout);
void        gnet_conn_disconnect            (GConn *conn,
                                             gboolean delete_buffers);
gboolean    gnet_conn_is_connected          (const GConn *conn);
void        gnet_conn_read                  (GConn *conn,
                                             gchar *buffer,
                                             guint length,
                                             guint timeout,
                                             gboolean read_one_byte_at_a_time,
                                             GNetIOChannelReadAsyncCheckFunc check_func,
                                             gpointer check_user_data);
void        gnet_conn_readany               (GConn *conn,
                                             gchar *buffer,
                                             guint length,
                                             guint timeout);
void        gnet_conn_readline              (GConn *conn,
                                             gchar *buffer,
                                             guint length,
                                             guint timeout);
void        gnet_conn_write                 (GConn *conn,
                                             gchar *buffer,
                                             gint length,
                                             guint timeout);
void        gnet_conn_timeout               (GConn *conn,
                                             guint timeout);
void        gnet_conn_watch_add_read        (GConn *conn,
                                             GIOFunc func,
                                             gpointer user_data);
void        gnet_conn_watch_add_write       (GConn *conn,
                                             GIOFunc func,
                                             gpointer user_data);
void        gnet_conn_watch_add_error       (GConn *conn,
                                             GIOFunc func,
                                             gpointer user_data);
void        gnet_conn_watch_remove_read     (GConn *conn);
void        gnet_conn_watch_remove_write    (GConn *conn);
void        gnet_conn_watch_remove_error    (GConn *conn);

Description

Conn represents a TCP connection. New connections can be created and connected to. New connections can also by created by a Server.

Details

struct GConn

struct GConn
{
  gchar*			hostname;
  gint				port;

  guint				ref_count;

  GTcpSocketConnectAsyncID 	connect_id;
  GTcpSocketNewAsyncID 		new_id;

  GTcpSocket* 			socket;
  GInetAddr*			inetaddr;
  GIOChannel* 			iochannel;

  guint				read_watch;
  guint				write_watch;
  guint				err_watch;

  GNetIOChannelWriteAsyncID 	write_id;
  GList*			queued_writes;

  GNetIOChannelReadAsyncID  	read_id;

  guint				timer;

  GConnFunc			func;
  gpointer			user_data;

};


enum GConnStatus

typedef enum {
  GNET_CONN_STATUS_CONNECT,
  GNET_CONN_STATUS_CLOSE,
  GNET_CONN_STATUS_READ,
  GNET_CONN_STATUS_WRITE,
  GNET_CONN_STATUS_TIMEOUT,
  GNET_CONN_STATUS_ERROR
} GConnStatus;


GConnFunc ()

gboolean    (*GConnFunc)                    (GConn *conn,
                                             GConnStatus status,
                                             gchar *buffer,
                                             gint length,
                                             gpointer user_data);

conn : 
status : 
buffer : 
length : 
user_data : 
Returns : 


gnet_conn_new ()

GConn*      gnet_conn_new                   (const gchar *hostname,
                                             gint port,
                                             GConnFunc func,
                                             gpointer user_data);

hostname : 
port : 
func : 
user_data : 
Returns : 


gnet_conn_new_inetaddr ()

GConn*      gnet_conn_new_inetaddr          (const GInetAddr *inetaddr,
                                             GConnFunc func,
                                             gpointer user_data);

inetaddr : 
func : 
user_data : 
Returns : 


gnet_conn_delete ()

void        gnet_conn_delete                (GConn *conn,
                                             gboolean delete_buffers);

conn : 
delete_buffers : 


gnet_conn_ref ()

void        gnet_conn_ref                   (GConn *conn);

conn : 


gnet_conn_unref ()

void        gnet_conn_unref                 (GConn *conn,
                                             gboolean delete_buffers);

conn : 
delete_buffers : 


gnet_conn_connect ()

void        gnet_conn_connect               (GConn *conn,
                                             guint timeout);

conn : 
timeout : 


gnet_conn_disconnect ()

void        gnet_conn_disconnect            (GConn *conn,
                                             gboolean delete_buffers);

conn : 
delete_buffers : 


gnet_conn_is_connected ()

gboolean    gnet_conn_is_connected          (const GConn *conn);

conn : 
Returns : 


gnet_conn_read ()

void        gnet_conn_read                  (GConn *conn,
                                             gchar *buffer,
                                             guint length,
                                             guint timeout,
                                             gboolean read_one_byte_at_a_time,
                                             GNetIOChannelReadAsyncCheckFunc check_func,
                                             gpointer check_user_data);

conn : 
buffer : 
length : 
timeout : 
read_one_byte_at_a_time : 
check_func : 
check_user_data : 


gnet_conn_readany ()

void        gnet_conn_readany               (GConn *conn,
                                             gchar *buffer,
                                             guint length,
                                             guint timeout);

conn : 
buffer : 
length : 
timeout : 


gnet_conn_readline ()

void        gnet_conn_readline              (GConn *conn,
                                             gchar *buffer,
                                             guint length,
                                             guint timeout);

conn : 
buffer : 
length : 
timeout : 


gnet_conn_write ()

void        gnet_conn_write                 (GConn *conn,
                                             gchar *buffer,
                                             gint length,
                                             guint timeout);

conn : 
buffer : 
length : 
timeout : 


gnet_conn_timeout ()

void        gnet_conn_timeout               (GConn *conn,
                                             guint timeout);

conn : 
timeout : 


gnet_conn_watch_add_read ()

void        gnet_conn_watch_add_read        (GConn *conn,
                                             GIOFunc func,
                                             gpointer user_data);

conn : 
func : 
user_data : 


gnet_conn_watch_add_write ()

void        gnet_conn_watch_add_write       (GConn *conn,
                                             GIOFunc func,
                                             gpointer user_data);

conn : 
func : 
user_data : 


gnet_conn_watch_add_error ()

void        gnet_conn_watch_add_error       (GConn *conn,
                                             GIOFunc func,
                                             gpointer user_data);

conn : 
func : 
user_data : 


gnet_conn_watch_remove_read ()

void        gnet_conn_watch_remove_read     (GConn *conn);

conn : 


gnet_conn_watch_remove_write ()

void        gnet_conn_watch_remove_write    (GConn *conn);

conn : 


gnet_conn_watch_remove_error ()

void        gnet_conn_watch_remove_error    (GConn *conn);

conn :