Manuel de référence

Date de publication : 30/09/07 , Date de mise à jour : 31/10/07

Version PDF (Miroir) Version hors-ligne (Miroir)

II. Apprentissage
II-A. Le module d'initialisation
II-A-1. gnet_init()
II-A-2. GNET_CHECK_IVERSION()
II-B. Les InetAddr
II-B-1. Le type GInetAddr
II-B-2. gnet_inetaddr_new ()
II-B-3. gnet_inetaddr_new_async ()
II-B-4. Fonction callback et asynchronisme
II-B-5. gnet_inetaddr_new_async_cancel ()
II-B-6. gnet_inetaddr_new_list ()
II-B-7. gnet_inetaddr_delete_list ()
II-B-8. gnet_inetaddr_new_list_async ()
II-B-9. Liste chaînée d'InetAddr asynchrone
II-B-10. gnet_inetaddr_new_list_async_cancel ()
II-B-11. gnet_inetaddr_new_nonblock ()
II-B-12. Gestions des GInetAddr
II-B-12-a. gnet_inetaddr_clone ()
II-B-12-b. gnet_inetaddr_delete ()
II-B-12-c. gnet_inetaddr_ref ()
II-B-12-d. gnet_inetaddr_unref ()
II-B-12-e. gnet_inetaddr_get_name ()
II-B-12-f. gnet_inetaddr_get_length ()
II-B-12-g. gnet_inetaddr_get_port () et gnet_inetaddr_set_port ()
II-B-13. Test d'état des GInetAddr
II-B-13-a. gnet_inetaddr_is_internet()
II-B-13-b. gnet_inetaddr_is_private()
II-B-13-c. gnet_inetaddr_is_reserved()
II-B-13-d. gboolean gnet_inetaddr_is_loopback()
II-B-13-e. gboolean gnet_inetaddr_is_multicast()
II-B-13-f. gboolean gnet_inetaddr_is_broadcast()
II-B-13-g. gboolean gnet_inetaddr_is_ipv4()
II-B-13-h. gboolean gnet_inetaddr_is_ipv6()
II-B-14. gnet_inetaddr_equal() et gnet_inetaddr_noport_equal()
II-C. Les TCP-Sockets
II-C-1. Créer une TCP-Socket
II-C-2. Créer une TCP-socket asynchrone
II-C-3. Connexion de sockets TCP
II-C-3-a. Connecter une TCP-Socket synchrone
II-C-3-b. Connecter une socket asynchrone
II-C-4. Gestion des TCP-Socket
II-C-4-a. gnet_tcp_socket_get_remote_inetaddr()
II-C-4-b. gnet_tcp_socket_get_local_inetaddr()
II-C-4-c. gnet_tcp_socket_get_port()
II-C-4-d. gnet_tcp_socket_set_tos()
II-C-5. Suppression et références
II-C-6. Les TCP-Socket-Serveur
II-C-6-a. gnet_tcp_socket_server_new()
II-C-6-b. gnet_tcp_socket_server_new_with_port()
II-C-6-c. gnet_tcp_socket_server_new_full()
II-C-6-d. gnet_tcp_socket_server_accept()
II-C-6-e. gnet_tcp_socket_server_accept_nonblock()
II-C-6-f. gnet_tcp_socket_server_accept_async()
II-C-6-g. gnet_tcp_socket_new_direct()
II-C-6-h. gnet_tcp_socket_new_async_direct()
II-D. Les UDP-Sockets
II-D-1. Créer une UDP-Socket
II-D-2. Suppression et références de Socket-UDP
II-D-3. gnet_udp_socket_send() et gnet_udp_socket_receive()
II-D-3-a. gnet_udp_socket_send()
II-D-3-b. gnet_udp_socket_receive()
II-D-4. gnet_udp_socket_has_packet()
II-D-5. gnet_udp_socket_get_local_inetaddr()
II-D-6. gnet_udp_socket_get_ttl() et gnet_udp_socket_set_ttl ()
II-E. Les GMcastSocket
II-E-1. Créer une GMcastSocket
II-E-2. Références et suppression
II-E-2-a. gnet_mcast_socket_ref() et gnet_mcast_socket_unref()
II-E-2-b. gnet_mcast_socket_delete()
II-E-3. Les groupes
II-E-4. gnet_mcast_socket_get_ttl() et gnet_mcast_socket_set_ttl()
II-E-5. gnet_mcast_socket_get_local_inetaddr()
II-E-6. send, receIIe et has_packet
II-E-6-a. gnet_mcast_socket_send()
II-E-6-b. gnet_mcast_socket_receive()
II-E-6-c. gnet_mcast_socket_has_packet()
II-E-7. gnet_mcast_socket_to_udp_socket()
II-F. Les objets de connexions HTTP
II-F-1. Créer un GConHttp
II-F-2. gnet_conn_http_set_uri()
II-F-3. gnet_conn_http_run_async() ou gnet_conn_http_run()
II-F-3-a. gnet_conn_http_run_async()
II-F-3-b. gnet_conn_http_run()
II-F-4. Fonctions de contrôle
II-F-4-a. gnet_conn_http_set_header()
II-F-4-b. gnet_conn_http_set_max_redirects()
II-F-4-c. gnet_conn_http_set_timeout()
II-F-4-d. gnet_conn_http_set_user_agent()
II-F-4-e. gnet_conn_http_set_method()
II-F-5. gnet_conn_http_steal_buffer()
II-F-6. gnet_conn_http_delete() et gnet_conn_http_cancel()
II-F-6-a. gnet_conn_http_delete()
II-F-6-b. gnet_conn_http_cancel()
II-F-7. gnet_http_get()
II-G. Les objets de connexion TCP
II-G-1. Créer un objet de connexion TCP
II-G-2. Suppression et référence
II-G-3. gnet_conn_set_callback()
II-G-4. gnet_conn_connect(), gnet_conn_disconnect() et gnet_conn_is_connected()
II-G-5. Lecture/Ecriture
II-G-5-a. Lecture
II-G-5-b. Ecriture
II-G-6. gnet_conn_set_watch_error()
II-G-7. gnet_conn_set_watch_writable() et gnet_conn_set_watch_readable()
II-G-7-a. gnet_conn_set_watch_writable()
II-G-7-b. gnet_conn_set_watch_readable()
II-G-8. gnet_conn_timeout()
II-H. Les Serveurs TCP
II-H-1. Créer un Serveurs TCP
II-H-2. Rédrence et déréference
II-H-3. Suppression d'un GServer
II-I. Les IOChannels
II-I-1. Recupérer les IOChannel
II-I-2. Utiliser un GIOChannel
II-J. Les URI(Uniforme Ressource Identifier)
II-J-1. Créer un URI
II-J-1-a. gnet_uri_new()
II-J-1-b. gnet_uri_new_fields()
II-J-1-c. gnet_uri_new_fields_all()
II-J-2. Gestion des URI
II-J-2-a. gnet_uri_clone()
II-J-2-b. gnet_uri_escape()
II-J-2-c. gnet_uri_unescape()
II-J-2-d. gnet_uri_get_string()
II-J-2-e. gnet_uri_set_scheme()
II-J-2-f. gnet_uri_set_userinfo()
II-J-2-g. gnet_uri_set_hostname()
II-J-2-h. gnet_uri_set_port()
II-J-2-i. gnet_uri_set_path()
II-J-2-j. gnet_uri_set_query()
II-J-2-k. gnet_uri_set_fragment()
II-J-2-l. gnet_uri_equal()
II-K. Base64
II-K-1. gnet_base64_encode()
II-K-2. gnet_base64_decode()

II. Apprentissage

Dans cette partie, nous allons étudier en détails toute les possibilités de GNet, pour que vous puissiez complétement maîtrisez GNet à la fin de ce paragraphe. Nous allons donc revenir point par point sur les capacités de GNet.

II-A. Le module d'initialisation

Dans le module d'initialisation, on peut trouver la fonction d'initialisation, ainsi que deux macros sur lesquels nous reviendrons.

II-A-1. gnet_init()

la fonction gnet_init() initialise la librairie GNet, c'est la première fonction à appeler(si vous utilisez GTK, cette fonction doit être appelée avant gtk_init) voici son prototype :


void gnet_init(void);

Il n'y a pas grand chose à en dire de plus, en cas d'erreur, un message s'affichera à l'écran.

II-A-2. GNET_CHECK_IVERSION()

Ce macro fourni par GNet permet de tester une version de la librairie, voici son prototype :


#define GNET_CHECK_IVERSION(major,minor,micro)

Cela permet de voir si la version de la librairie est compatible avec celle envoyée, par exemple :


GNET_CHECK_IVERSION(1.2.3)

Retournera TRUE si la version de la librairie >= 1.2.3 et FALSE sinon.

II-B. Les InetAddr

Les InetAddr sont utilisés pour représenter une adresse internet qui sera utilisée ensuite, pour un socket par exemple. Il existe plusieurs type de GInetAddr, les synchrones, les asynchrones, les listes de GInetAddr.

II-B-1. Le type GInetAddr

C'est une simple définition de structure qui sera utilisée pour représenter une adresse internet, vous devez créer une variable de type GInetAddr :


typedef struct _GInetAddr GInetAddr;

II-B-2. gnet_inetaddr_new ()

Cette fonction permet de créer une nouvelle GInetAddr, voici son prototype :



GInetAddr* gnet_inetaddr_new(const gchar *hostname, gint port);

Il vous faut donc créer un pointeur sur une variable de type GInetAddr pour récupérer ce que renvoie la fonction, et ne pas oublier de tester la valeur de retour (NULL en cas d'erreur).

II-B-3. gnet_inetaddr_new_async ()

Cette fonction permet de créer une adresse internet asynchrone (utilisant le système de callback), voici son prototype :



GInetAddrNewAsyncID gnet_inetaddr_new_async (const gchar *hostname, gint port, GInetAddrNewAsyncFunc func, gpointer data);

Les utilisateurs de GTK reconnaîtront le système de callback, quelques précisions sur les paramètres :

hostname : nom du serveur
port : numéro de port
func : fonction callback
data : donnée à passer à la fonction callback
Retour : un pointeur de type GInetAddrNewAsyncID, NULL en cas d'erreur

Nous allons revenir sur ces points.

II-B-4. Fonction callback et asynchronisme

Il nous faut donc connecter une fonction callback à GInetAddrNewAsyncID, pour cela il faut créer une fonction de type callback ayant ce prototype :



void user_fonction(GInetAddr *inetaddr, gpointer data);

Créez donc votre fonction callback, une fois créé, il faut la connecter avec une GInetAddrNewAsyncID, pour cela, il faut utiliser un pointeur sur votre fonction callback, ainsi déclaré :



void (*GInetAddrNewAsyncFunc) (GInetAddr *inetaddr, gpointer data);

Une fois effectué, vous pouvez donner ce pointeur en paramètre à la fonction gnet_inetaddr_new_async

II-B-5. gnet_inetaddr_new_async_cancel ()

Cette fonction, dont voici le prototype :



void gnet_inetaddr_new_async_cancel(GInetAddrNewAsyncID id);

Permet d'annuler une GInetAddr asynchrone dont on donne l'ID (normalement récupérée avec la fonction gnet_inetaddr_new_async ()).

II-B-6. gnet_inetaddr_new_list ()

Cette fonction dont voici le prototype :



GList* gnet_inetaddr_new_list(const gchar *hostname, gint port);

Permet de créer une liste chaînée (la GList de la glib) d'InetAddr à partir d'un nom de serveur et d'un numéro de port, cette fonction retourne un pointeur sur une GList, NULL en cas d'erreur.

II-B-7. gnet_inetaddr_delete_list ()

Cette fonction :


void gnet_inetaddr_delete_list(GList *list);

permet de supprimer la GList de GInetAddr qu'elle prend en paramètre.

II-B-8. gnet_inetaddr_new_list_async ()

Cette fonction dont voici le prototype :



GInetAddrNewListAsyncID gnet_inetaddr_new_list_async(const gchar *hostname, gint port, GInetAddrNewListAsyncFunc func, gpointer data);

permet de créer une liste de GInetAddr asynchrone.

hostname : nom du serveur.
port : numéro de port.
func : fonction callback.
data : donnée à passer à la fonction callback.
Retour : Une GInetAddrNewListAsyncID, NULL en cas d'erreur.

Le fonctionnement est quasiment le même que pour gnet_inetaddr_new_async(), à quelques exceptions que nous allons mentionner.

II-B-9. Liste chaînée d'InetAddr asynchrone

Comme tout à l'heure, il faut créer une fonction callback, dont le prototype doit être :


void user_fonction(GList *list, gpointer data);

Ensuite, il faut créer un pointeur sur cette fonction :



void (*GInetAddrNewListAsyncFunc) (GList *list,  gpointer data);

Puis on peut passer ce pointeur à la fonction gnet_inetaddr_new_list_async ().

II-B-10. gnet_inetaddr_new_list_async_cancel ()

Cette fonction :



void gnet_inetaddr_new_list_async_cancel(GInetAddrNewListAsyncID id);

Permet d'annuler la liste chaînée de GInetAddr asynchrone passée en argument.

II-B-11. gnet_inetaddr_new_nonblock ()

Cette fonction :



GInetAddr*  gnet_inetaddr_new_nonblock(const gchar *hostname, gint port);

Permet de créer une GInetAddr depuis un nom de serveur et un port sans blocage.
Cette fonction renvoie une GInetAddr ou bien NULL s'il y a une erreur où si la fonction à été bloquée.

II-B-12. Gestions des GInetAddr

Dans cette partie nous allons voir divers fonctions de gestion des GInetAddr.

II-B-12-a. gnet_inetaddr_clone ()

Cette fonction :



GInetAddr*  gnet_inetaddr_clone(const GInetAddr *inetaddr);

Permet de cloner la GInetAddr donnée en argument.

II-B-12-b. gnet_inetaddr_delete ()

Cette fonction dont voici le prototype :


void gnet_inetaddr_delete(GInetAddr *inetaddr);

Permet de supprimer la GInetAddr donnée en argument.

II-B-12-c. gnet_inetaddr_ref ()

Cette fonction :


void gnet_inetaddr_ref(GInetAddr *inetaddr);

Permet d'ajouter une référence à la GInetAddr donnée en argument.

II-B-12-d. gnet_inetaddr_unref ()

Cette fonction :


void gnet_inetaddr_unref(GInetAddr *inetaddr);

permet d'enlever une référence au GInetAddr donnée en argument, lorsqu'une GInetAddr n'a plus aucune référence, elle est détruite.

II-B-12-e. gnet_inetaddr_get_name ()

Cette fonction dont voici le prototype :



gchar* gnet_inetaddr_get_name(GInetAddr *inetaddr);

permet de récupérer le nom du serveur qui a été attribué à la GInetAddr donnée en argument. Elle retourne NULL en cas d'erreur.

II-B-12-f. gnet_inetaddr_get_length ()

Cette fonction :



gint gnet_inetaddr_get_length(const GInetAddr *inetaddr);

Permet de récupérer la taille d'une adresse d'une GInetAddr en octets.

II-B-12-g. gnet_inetaddr_get_port () et gnet_inetaddr_set_port ()

Ces deux fonctions :



gint gnet_inetaddr_get_port(const GInetAddr *inetaddr);
void gnet_inetaddr_set_port(const GInetAddr *inetaddr, gint port);

Permettent respectivement :

D'obtenir le numéro de port attribué à la GInetAddr passé en argument
D'attribuer le numéro de port passé en argument à la GInetAddr passé en argument

II-B-13. Test d'état des GInetAddr

GNet propose pas moins de 8 fonctions permettant de tester l'état d'une GInetAddr, que voici :



gboolean gnet_inetaddr_is_internet(const GInetAddr *inetaddr);
gboolean gnet_inetaddr_is_private(const GInetAddr *inetaddr);
gboolean gnet_inetaddr_is_reserved(const GInetAddr *inetaddr);
gboolean gnet_inetaddr_is_loopback(const GInetAddr *inetaddr);
gboolean gnet_inetaddr_is_multicast(const GInetAddr *inetaddr);
gboolean gnet_inetaddr_is_broadcast(const GInetAddr *inetaddr);
gboolean gnet_inetaddr_is_ipv4(const GInetAddr *inetaddr);
gboolean gnet_inetaddr_is_ipv6(const GInetAddr *inetaddr);

Nous allons à présent revenir sur chacune de ces fonctions :

II-B-13-a. gnet_inetaddr_is_internet()

Cette fonction renvoie TRUE si le nom de la GInetAddr donnée en argument est une adresse internet.

II-B-13-b. gnet_inetaddr_is_private()

Cette fonction retourne TRUE si la GInetAddr est privée ou réservée pour un réseau particulier.

II-B-13-c. gnet_inetaddr_is_reserved()

Cette fonction renvoie TRUE si la GInetAddr passée en argument est réservée pour un but quelconque, réseaux privés exclus.

II-B-13-d. gboolean gnet_inetaddr_is_loopback()

Cette fonction renvoie TRUE si la GInetAddr est une adresse "loopback".

II-B-13-e. gboolean gnet_inetaddr_is_multicast()

Cette fonction renvoie TRUE si la GInetAddr passée en argument est multicast.

II-B-13-f. gboolean gnet_inetaddr_is_broadcast()

Cette fonction renvoie TRUE si la GInetAddr passée en argument est une adresse Broadcast

II-B-13-g. gboolean gnet_inetaddr_is_ipv4()

Cette fonction retourne TRUE si la GInetAddr passée en argument est une adresse IPv4.

II-B-13-h. gboolean gnet_inetaddr_is_ipv6()

Cette fonction renvoie TRUE si la GInetAddr passée en argument est une adresse IPv6.

II-B-14. gnet_inetaddr_equal() et gnet_inetaddr_noport_equal()

Cette fonction :



gboolean gnet_inetaddr_equal(gconstpointer p1, gconstpointer p2);

permet de comparer les deux GInetAddr données en argument, si elles sont équivalentes, la fonction renvoie TRUE, FALSE dans les autres cas.
Cette fonction :



gboolean gnet_inetaddr_noport_equal(gconstpointer p1, gconstpointer p2);

permet de comparer les GInetAddr données en argument, mais sans tenir compte des numéros de port, elle renvoie TRUE en cas d'égalité, FALSE sinon.

Dans ce paragraphe, nous avons fait le tour des GInetAddr qui servent à représenter les adresses internet, elles nous seront utiles pour les sockets par exemple.

II-C. Les TCP-Sockets

TCP est un protocole internet interne permettant d'échanger des informations qui arrivent dans l'ordre, les TCP Sockets fournis par GNet sont les GTcpSocket.
Dans cette partie nous allons étudier le support que fournit GNet pour les sockets TCP.

II-C-1. Créer une TCP-Socket

Il y a trois étapes :

Création et initialisation d'une GInetAddr
Création d'un pointeur de type GTcpSocket
Utilisation de la fonction gnet_tcp_socket_new(const GInetAddr *addr).

Admettons que la première soit remplie, il nous reste la deuxième et la troisième :



GTcpSocket* TcpSocket = gnet_tcp_socket_new(InetAddr);

La fonction renvoie NULL en cas d'erreur.

II-C-2. Créer une TCP-socket asynchrone

Pour créer une TCP-Socket Asynchrone, il y a 4 étapes :

Créer une variable de type GTcpSocketNewAsyncID
Créer une fonction callback de prototype : void user_fonction(GTcpSocket *socket, gpointer data).
Créer un pointeur sur la fonction callback
Créer la TCP-Socket asynchrone avec la fonction GTcpSocketNewAsyncID gnet_tcp_socket_new_async(const GInetAddr *addr, GTcpSocketNewAsyncFunc func, gpointer data).

Pour créer la variable, pas de problème, pour la fonction callback et le pointeur sur la fonction, pas de problème non plus, nous allons détailler la fonction :


gnet_tcp_socket_new_async(const GInetAddr *addr, GTcpSocketNewAsyncFunc func,  gpointer data);

Examinons les arguments :

addr : la GInetAddr représentant l'dresse.
func : le pointeur sur la fonction callback.
data : une donnée quelconque à passer à la fonction callback.
valeur de retour : Une TCP-Socket asynchrone, NULL en cas d'erreur.

II-C-3. Connexion de sockets TCP

II-C-3-a. Connecter une TCP-Socket synchrone

Pour connecter une TCP-Socket synchrone, on utilise cette fonction :


GTcpSocket* gnet_tcp_socket_connect(const gchar *hostname, gint port);

Cette fonction crée une TCP-Socket, qu'elle connecte au serveur hostname et au port donné en argument, il faut donc récupérer la TCP-Socket qu'elle renvoie(cette fonction renvoie NULL en cas d'erreur).

II-C-3-b. Connecter une socket asynchrone

Pour connecter une socket asynchrone, on utilise cette fonction :


GTcpSocketConnectAsyncID gnet_tcp_socket_connect_async(const gchar *hostname, gint port, GTcpSocketConnectAsyncFunc func, gpointer data);

créé une TCP-Socket asynchrone et la connecte au serveur hostname au port passé en argument, examinons cette fonction de plus près :

hostname : nom du serveur
port : port
func : fonction callback
data : donnée à passer à la fonction callback
Retour : L'ID de la connection. NULL en cas d'erreur.

Comme toujours, on crée une fonction callback ayant ce prototype :


void user_fonction(GTcpSocket *socket, gpointer data);

Puis on crée un pointeur sur cette fonction :


void (*GTcpSocketNewAsyncFunc) (GTcpSocket *socket, gpointer data);

que l'on passe en troisième argument, le quatrième argument correspondant au deuxième argument de la fonction callback.

II-C-4. Gestion des TCP-Socket

La librairie GNet fournit pas moins de 4 fonctions de gestions des TCP-Socket, qui sont celles-ci :


GInetAddr* gnet_tcp_socket_get_remote_inetaddr(const GTcpSocket *socket);
GInetAddr* gnet_tcp_socket_get_local_inetaddr(const GTcpSocket *socket);
gint gnet_tcp_socket_get_port(const GTcpSocket *socket);
void gnet_tcp_socket_set_tos(GTcpSocket *socket, GNetTOS tos);

Bien que leur rôle soit assez explicite, nous allons revenir sur ces fonctions une par une.

II-C-4-a. gnet_tcp_socket_get_remote_inetaddr()

Cette fonction permet de récupérer la GInetAddr du serveur distant de la TCP-Socket passée en argument.

II-C-4-b. gnet_tcp_socket_get_local_inetaddr()

Cette fonction permet de récupérer la GInetAddr du serveur locale de la TCP-Socket fournie en argument.

II-C-4-c. gnet_tcp_socket_get_port()

Cette fonction permet de récupérer le port de la TCP-Socket fourni en argument.

II-C-4-d. gnet_tcp_socket_set_tos()

Cette fonction permet de définir le type de service(TOS) de la TCP-Socket fournie en argument. Les TOS devraient théoriquement être contrôlés, mais la plupart des routeurs les ignorent. De plus certains systèmes ne les supportent pas. Il faut donner en argument un GNetTOS, dont voici la définition :


typedef enum
{
  GNET_TOS_NONE,
  GNET_TOS_LOWDELAY,
  GNET_TOS_THROUGHPUT,
  GNET_TOS_RELIABILITY,
  GNET_TOS_LOWCOST
} GNetTOS;

Examinons à présent ces différentes valeurs :

GNET_TOS_NONE Non spécifié
GNET_TOS_LOWDELAY Petit retard
GNET_TOS_THROUGHPUT Sortie élevée
GNET_TOS_RELIABILITY Fiabilitée élevée
GNET_TOS_LOWCOST Faible coût

Choisissez celle qui correspond et passez là en argument.

II-C-5. Suppression et références

Pour supprimer une TCP-Socket, ces fonctions sont à votre disposition(dépendant de votre type de socket) :


void gnet_tcp_socket_delete(GTcpSocket *socket);
void gnet_tcp_socket_new_async_cancel(GTcpSocketNewAsyncID id);

Pour la première, cela supprime la TCP-Socket passée en argument. Pour la deuxième, cela annule la TCP-Socket asynchrone dont l'ID est fourni est argument.

Il y a toujours le système de référence(semblable à celui des GInetAddr) :


// Pour ajouter une référence à une TCP-Socket
void gnet_tcp_socket_ref(GTcpSocket *socket);
// Pour oter une référence à une TCP-Socket
void gnet_tcp_socket_unref(GTcpSocket *socket);

N'oubliez pas que lorsque le nombre de références à une TCP-Socket atteint zéro, elle est détruite, un peu comme le Garbage Collector de Java.

II-C-6. Les TCP-Socket-Serveur

Pour cela, examinons quelques fonctions.

II-C-6-a. gnet_tcp_socket_server_new()

Cette fonction :


GTcpSocket* gnet_tcp_socket_server_new();

Crée une nouvelle GTcpSocket liée à toutes les interfaces et à un port arbitraire. Des socks sont employés si les socks sont permis. Cette fonction renvoie NULL en cas d'erreur.

II-C-6-b. gnet_tcp_socket_server_new_with_port()

Cette fonction, dont voici le prototype :


GTcpSocket* gnet_tcp_socket_server_new_with_port(gint port);

Crée une nouvelle GTcpSocket liée à toutes les interfaces et au port donné en argument. Si le port est 0, un port arbitraire sera employé. Des socks sont employés si les socks sont permis. Cette fonction retourne également NULL en cas d'erreur.

II-C-6-c. gnet_tcp_socket_server_new_full()

Cette fonction :


GTcpSocket* gnet_tcp_socket_server_new_full(const GInetAddr *iface, gint port);

Crée une nouvelle GTcpSocket liée à l'interface iface et au port passé en argument. Si iface est égale à NULL, la TCP-Socket est liée à toutes les interfaces. Si le port est 0, la socket est liée à un port arbitraire. Des socks sont employés si les socks sont permis et que l'interface est égale à NULL. Cette fonction retourne NULL en cas d'erreur ou une TCP-Socket si tout s'est bien passé.

II-C-6-d. gnet_tcp_socket_server_accept()

Cette fonction dont voici le prototype :


GTcpSocket* gnet_tcp_socket_server_accept(GTcpSocket *socket);

Accepte une connexion d'une GTcpSocket. Le socket doit avoir été créé en utilisant gnet_tcp_socket_server_new() (ou équIIalent). Même si le GIOChannel du socket est lisible, la fonction peut être bloquée. Cette fonction retourne une nouvelle TCP-socket représentant la connexion, ou bien NULL en cas d'erreur.

II-C-6-e. gnet_tcp_socket_server_accept_nonblock()

Cette fonction :


GTcpSocket* gnet_tcp_socket_server_accept_nonblock(GTcpSocket *socket);

Accepte un raccordement d'un GTcpSocket sans blocage. La socket doit avoir été créée en utilisant gnet_tcp_socket_server_new () (ou équIIalent).
Noter que si le GIOChannel de la socket est lisible, alors il y a PROBABLEMENT une nouvelle connexion. Il est possible que la connexion soit fermée avant que cette fonction ne soit appelée, dans ce cas, la fonction renvoie NULL.

II-C-6-f. gnet_tcp_socket_server_accept_async()

Cette fonction dont voici le prototype :


void gnet_tcp_socket_server_accept_async(GTcpSocket *socket, GTcpSocketAcceptFunc accept_func, gpointer user_data);

Accepte une connexion asynchrone d'une GTcpSocket. La fonction callback est appelée quand un nouveau client se connecte ou quand une erreur se produit. La TCP-Socket doit avoir été créée en utilisant gnet_tcp_socket_server_new () (ou équivalent).
Comme toujours procédons de la même façon, examinons cette fonction de plus près :

socket : une GTcpSocket
accept_func : un pointeur sur une fonction callback.
user_data : une donnée supplémentaire quelconque à passer en argument à la fonction callback

A présent essayons de remplir ces conditions, tout d'abord, il faut créer une fonction callback suivant ce prototype :


void user_fonction(GTcpSocket *server, GTcpSocket *client, gpointer data);

Puis créons un pointeur sur cette fonction callback :


void (*GTcpSocketAcceptFunc) (GTcpSocket *server, GTcpSocket *client, gpointer data);

Ensuite, vous n'avez plus qu'a passer ce pointeur en deuxième argument à la fonction gnet_tcp_socket_server_accept_async().

Cette fonction quant à elle :


void gnet_tcp_socket_server_accept_async_cancel(GTcpSocket *socket);

Stope une connxeion asynchrone de socket acceptée. La socket n'est pas supprimée.

II-C-6-g. gnet_tcp_socket_new_direct()

Cette fonction :


GTcpSocket* gnet_tcp_socket_new_direct(const GInetAddr *addr);

Crée un GTcpSocket et la connecte à la GInetAddr donnée en argument sans employer de socks. Cette fonction est bloquante. La plupart des utilisateurs devraient plutôt employer gnet_tcp_socket_new ().

II-C-6-h. gnet_tcp_socket_new_async_direct()

Crée une GTcpSocket asynchrone et la connect à la GInetAddr fournie en argument sans employer de socks. La plupart des utilisateurs devraient plutôt employer gnet_tcp_socket_new_async () à la place. La fonction callback est appelée une fois que la connexion est établie ou si une erreur se produit. La fonction callback ne sera pas appelée pendant l'appel de cette fonction.
Examinons cette fonction de plus près :

addr : l'adresse.
func : la fonction callback.
data : une donnée à passer à la fonction callback.
Returns : L'ID de la connexion.

Cette fonction renvoie NULL en cas d'erreur. Pour annuler la connexion, utilisez la fonction gnet_tcp_socket_async_cancel().

II-D. Les UDP-Sockets

UDP est un protocole Internet interne où les paquets sont transmis du mieux possible. Les paquets peuvent arriver dans un autre ordre que celui de départ. Alors, s'il vous faut quelque chose de fiable, utilisez plutôt TCP.
Dans cette partie, nous allons examiner le support que GNet nous offre pour les Socket UDP : les GUdpSockets.

II-D-1. Créer une UDP-Socket

Pour créer une UDP-Socket, plusieurs fonctions sont à votre disposition :


// Créé une socket limitées à toutes les interfaces et à un port arbitraire
GUdpSocket* gnet_udp_socket_new();

// Créé une socket limitées à toutes les interfaces et au port donné en argument
GUdpSocket* gnet_udp_socket_new_with_port(gint port);

// Crée une socket limitée à l'interface donnée en argument et au port passé en argument
GUdpSocket* gnet_udp_socket_new_full(const GInetAddr *iface, gint port);

Ces trois fonctions renvoient NULL en cas d'erreur, il est nécessaire de récupérer la valeur de retour dans un pointeur de type GUdpSocket.

II-D-2. Suppression et références de Socket-UDP

Comme pour les TCP-Sockets, il est possible d'ajouter une référence et d'oter une référence à la Socket-UDP passée en argument, pour cela on utilise les fonctions :


// ajoute une référence à la Socket-UDP passé en argument
void gnet_udp_socket_ref(GUdpSocket *socket);

// retire une référence à la socket passé en argument
void gnet_udp_socket_unref(GUdpSocket *socket);

N'oubliez pas que lorsque le nombre de références à une UDP-Socket atteint zéro, celle-ci est supprimée.
Pour supprimer directement une UDP-Socket, on utilise cette fonction :


void gnet_udp_socket_delete(GUdpSocket *socket);

Qui supprime tout simplement la UDP-Socket passée en argument.

II-D-3. gnet_udp_socket_send() et gnet_udp_socket_receive()

II-D-3-a. gnet_udp_socket_send()

Cette fonction :


gint gnet_udp_socket_send(GUdpSocket *socket, const gchar *buffer, gint length, const GInetAddr *dst);

Envoie une donnée au serveur en utilisant l'UDP-Socket donnée en argument, revenons d'un peu plus près sur cette fonction :

socket : une GUdpSocket.
buffer : donnée à envoyer.
length : taille de la donnée.
dst : adresse de destination.
Retourne : 0 si tous c'est bien passé, un autre nombre dans le cas contraire.

II-D-3-b. gnet_udp_socket_receive()

Cette fonction, dont voici le prototype :


gint gnet_udp_socket_receIIe(GUdpSocket *socket, gchar *buffer, gint length, GInetAddr **src);

Reçoit des données en utilisant une GUdpSocket. Là aussi, examinons la fonction :

socket : une GUdpSocket
buffer : un buffer dans lequel écrire les données
length : taille du buffer(par sécurité)
src : un pointeur vers l'adresse source(optionnel)
Retourne : le nombre d'octets reçus, -1 en cas d'erreur.

Si vous donnez src, l'adresse source est stockée à l'endroit mémoire pointé par src.

II-D-4. gnet_udp_socket_has_packet()

Cette fonction :


gboolean gnet_udp_socket_has_packet(const GUdpSocket *socket);

Testes si la GUdpSocket donnée en argument a un paquet qui attend d'être reçu avec gnet_udp_socket_receive(). Elle renvoie TRUE si un paquet est en attente, FALSE sinon.

II-D-5. gnet_udp_socket_get_local_inetaddr()

Cette fonction, dont voici le prototype :


GInetAddr* gnet_udp_socket_get_local_inetaddr(const GUdpSocket *socket);

Permet de récupérer la GInetAddr correspondant à la GUdpSocket passée en argument.

II-D-6. gnet_udp_socket_get_ttl() et gnet_udp_socket_set_ttl ()

Ces deux fonctions :


gint gnet_udp_socket_get_ttl(const GUdpSocket *socket);
gint gnet_udp_socket_set_ttl(GUdpSocket *socket, gint ttl);

Permettent réciproquement de récupérer le TTL(Time To Live) de la GUdpSocket passée en argument et d'en imposer un à la socket passée en argument. Pour imposer un TTL correspondant à celui par défaut du kernel, il vous suffit d'envoyer -1 à la fonction gnet_udp_socket_set_ttl().

II-E. Les GMcastSocket

Dans cette partie, nous allons étudier le support que GNet fournit pour les sockets multicast.
Une socket multicast est représentée par un pointeur de type GMcastSocket.

II-E-1. Créer une GMcastSocket

Pour créer une socket multicast, ces trois fonctions sont à notre disposition :


// Créé un socket multicast lié à toutes les interfaces et à un port arbitraire
GMcastSocket* gnet_mcast_socket_new();

// Créé un socket multicast lié à toutes les interfaces et au port donné en argument
GMcastSocket* gnet_mcast_socket_new_with_port(gint port);

// Créé un socket multicast lié à l'interface donnée en argument et au port passé en argument
GMcastSocket* gnet_mcast_socket_new_full(const GInetAddr *iface, gint port);

II-E-2. Références et suppression

Le système de référence/déréference est toujours valable pour les sockets multicast.

II-E-2-a. gnet_mcast_socket_ref() et gnet_mcast_socket_unref()

Ces deux fonctions :


void gnet_mcast_socket_ref(GMcastSocket *socket);
void gnet_mcast_socket_unref(GMcastSocket *socket);

permettent respectivement :

D'ajouter une référence à la socket multicast passée en argument
D'enlever une référence à la socket multicast passée en argument

N'oubliez pas de tenir compte du fait que lorsque le nombre de référence à une socket multicast atteint zéro, elle est détruite.

II-E-2-b. gnet_mcast_socket_delete()

Cette fonction :


void gnet_mcast_socket_delete(GMcastSocket *socket);

Permet de détruire la socket multicast passée en argument.

II-E-3. Les groupes

Pour rejoindre un groupe, utilisez cette fonction :


gint gnet_mcast_socket_join_group(GMcastSocket *socket, const GInetAddr *inetaddr);

Et cette fonction pour quitter un groupe :


gint gnet_mcast_socket_leave_group(GMcastSocket *socket, const GInetAddr *inetaddr);

II-E-4. gnet_mcast_socket_get_ttl() et gnet_mcast_socket_set_ttl()

Ces deux fonctions :


gint gnet_mcast_socket_get_ttl(const GMcastSocket *socket);
gint gnet_mcast_socket_set_ttl(GMcastSocket *socket, gint ttl);

Servent respectivement à obtenir le ttl(Time To LIIe) en vigueur et à en imposer un.

II-E-5. gnet_mcast_socket_get_local_inetaddr()

Cette fonction :


GInetAddr* gnet_mcast_socket_get_local_inetaddr(const GMcastSocket *socket);

Permet de récupérer la GInetAddr locale de la socket multicast passée en argument.

II-E-6. send, receIIe et has_packet

II-E-6-a. gnet_mcast_socket_send()

Cette fonction :


gint gnet_mcast_socket_send(GMcastSocket *socket, const gchar *buffer, gint length, const GInetAddr *dst);

Est exactement la même que pour les autres types de sockets, revenons tout de même sur ses arguments :

socket : une GMcastSocket
buffer : un buffer à envoyer
length : la taille du buffer
dst : l'adresse de destination
Retourne : 0 si tous se passe bien.

II-E-6-b. gnet_mcast_socket_receive()

Cette fonction, dont voici le prototype :


gint gnet_mcast_socket_receIIe(GMcastSocket *socket, gchar *buffer, gint length, GInetAddr **src);

Permet de récupérer une donée en attente, si src est passée à la fonction, l'adresse sera contenue à l'endroit que pointe src. Examinons à nouveau les paramètres :

socket : uneGMcastSocket.
buffer : un buffer dans lequel écrire la donnée.
length : la taille du buffer.
src : pointeur vers l'adresse source.
Retourne : le nombre d'octes reçu, -1 si il y a une erreur.

II-E-6-c. gnet_mcast_socket_has_packet()

Cette fonction :


gboolean gnet_mcast_socket_has_packet(const GMcastSocket *socket);

Vérifies si un paquet est en attente, si c'est le cas, elle renvoie TRUE, sinon FALSE.

II-E-7. gnet_mcast_socket_to_udp_socket()

Ce macro définit comme suit :


#define gnet_mcast_socket_to_udp_socket(MS) ((GUdpSocket*) (MS))

Convertit un GMcastSocket en un GUdpSocket. Un GMcastSocket est un dérivé d'un GUdpSocket.

II-F. Les objets de connexions HTTP

Un objet de connexion HTTP représente une connexion client. GNet offre un support pour les objets de connexion HTTP :


typedef struct _GConnHttp GConnHttp;

II-F-1. Créer un GConHttp

Pour créer un GConHttp, on utilise cette fonction :


GConnHttp* gnet_conn_http_new();

Qui retourne un GConHttp.

II-F-2. gnet_conn_http_set_uri()

Après avoir créé un GConHttp, vous pouvez imposer l'URI, en utilisant cette fonction :


gboolean gnet_conn_http_set_uri(GConnHttp *conn, const gchar *uri);

Cette fonction renvoie TRUE si l'URI a été accepté, FALSE sinon.

II-F-3. gnet_conn_http_run_async() ou gnet_conn_http_run()

Pour démarrer une connexion d'un GConHttp, vous pouvez utiliser ces deux fonctions :


void gnet_conn_http_run_async(GConnHttp *conn, GConnHttpFunc func, gpointer user_data);
gboolean gnet_conn_http_run(GConnHttp *conn, GConnHttpFunc func, gpointer user_data);

II-F-3-a. gnet_conn_http_run_async()

Démarre la connexion et envois la requête HTTP spécifiée. Le retour est immédiat. Cette fonction suppose que la boucle GTK/Glib/Gnome par défaut est activée. Revenons sur cette fonction :

conn : un objet de connexion HTTP
func : la fonction callback à laquelle est communiquée l'état d'avance, le déroulement et les erreurs
user_data : une donnée supplémentaire quelconque à donner à la fonction callback

Pour commencer, vous devez créer une fonction callback suivant ce prototype :


void user_fonction(GConnHttp *conn, GConnHttpEvent *event, gpointer user_data);

Ensuite, vous devez créer un pointeur sur cette fonction que vous devez passer à la fonction gnet_conn_http_run_async().

II-F-3-b. gnet_conn_http_run()

Cette fonction démarre la connexion et envois la requête HTTP spécifiée. Cette fonction s'arrêtera une fois l'opération finie (les données reçues) ou en cas d'erreur. Cette fonction crééra sa propre boucle interne. Regardons cette fonction de plus près :

conn : un GConnHttp.
func : un pointeur sur la fonction callback à qui communiquer la progression ou les erreurs.
user_data : une donnée quelconque à passer à la fonction callback.
Retour : TRUE si tout s'est bien déroulé, FALSE sinon.

Le principe de fonction callback est identique à celui évoqué pour les autres fonctions du même type

II-F-4. Fonctions de contrôle

Dans cette partie, nous verrons les fonctions qu'offre la librairie GNet pour contrôler les GConHttp.

II-F-4-a. gnet_conn_http_set_header()

Cette fonction :


gboolean gnet_conn_http_set_header(GConnHttp *conn, const gchar *field, const gchar *value, GConnHttpHeaderFlags flags);

Permet de définir l'entête de la requête HTTP envoyée. Pour comprendre cette fonction, il nous faut aussi étudier les GConHttpHeaderFlags qui sont définis tels quels :


typedef enum
{
  GNET_CONN_HTTP_FLAG_SKIP_HEADER_CHECK  = 1
} GConnHttpHeaderFlags;

Revenons donc sur cette fonction :

conn : un GConnHttp
field : un champ d'entête, par exemple : "Accept"
value : la valeur de l'entête, par exemple : "text/html"
flags : une ou plusieurs options de GConnHttpHeaderFlags
Retourne : TRUE si le header est correct et accepté

II-F-4-b. gnet_conn_http_set_max_redirects()

Cette fonction dont voici le prototype :


void gnet_conn_http_set_max_redirects(GConnHttp *conn, guint num);

Permet d'imposer un nombre maximum de redirections automatiques. Notez que le protocole HTTP spécifie les occasions où le client ne doit pas être redirigé automatiquement sans l'intervention de l'utilisateur. Dans ces cas aucune redirection automatique n'est effectuée, même si le nombre maximum de redirections automatiques n'a pas été dépassé.

II-F-4-c. gnet_conn_http_set_timeout()

Cette fonction :


void gnet_conn_http_set_timeout(GConnHttp *conn, guint timeout);

Permet de définir le temp après lequel la connexion s'arrêtera.

II-F-4-d. gnet_conn_http_set_user_agent()

Cette fonction, dont voici le prototype :


gboolean gnet_conn_http_set_user_agent(GConnHttp *conn, const gchar *agent);

Cette fonction est une encapsulation de la fonction gnet_conn_http_set_header().

II-F-4-e. gnet_conn_http_set_method()

Cette fonction :


gboolean gnet_conn_http_set_method(GConnHttp *conn, GConnHttpMethod method, const gchar *post_data,  gsize post_data_len);

Permet de définir la méthode de requête HTTP par défaut, par défaut c'est GET. IIous vous en doutez, GConHttpMethod est une énumération avec les deux valeurs POST et GET définit ainsi :


typedef enum
{
 GNET_CONN_HTTP_METHOD_GET,
 GNET_CONN_HTTP_METHOD_POST
} GConnHttpMethod;

Revenons tout de même sur cette fonction si vous le voulez bien :

conn : un GConnHttp.
method : une des deux valeurs GConnHttpMethod.
post_data : une donnée à envoyé avec POST.
post_data_len : la taille de la donée à envoyer avec POST ou alors 0.
Returns : TRUE si le changement s'est correctement déroulé.

II-F-5. gnet_conn_http_steal_buffer()

Cette fonction, dont voici le prototype :


gboolean gnet_conn_http_steal_buffer(GConnHttp *conn, gchar **buffer, gsize *length);

IIide le buffer et retourne le contenu. La principale utilitée de cette fonction est de faire en sorte qu'il soit possible d'appeler uniquement la fonction gnet_conn_http_run(), vérifier sa valeur de retour et obtenir alors les données du buffer sans devoir créer une fonction callback.

II-F-6. gnet_conn_http_delete() et gnet_conn_http_cancel()

II-F-6-a. gnet_conn_http_delete()

Cette fonction :


void gnet_conn_http_delete(GConnHttp *conn);

permet de supprimer le GConHttp passé en argument.

II-F-6-b. gnet_conn_http_cancel()

Cette fonction, dont voici le prototype :


void gnet_conn_http_cancel(GConnHttp *conn);

Annule la connexion en cours.

II-F-7. gnet_http_get()

Cette fonction :


gboolean gnet_http_get(const gchar *url, gchar **buffer, gsize *length, guint *response);

Cette fonction simplifie la vie et évite les appels à la fonction gnet_conn_http_run() qui se fait en interne. Après avoir appelé cette fonction, n'oubliez pas de libérer l'espace mémoire du buffer avec la fonction g_free(). Revenons de plus près sur cette fonction :

url : une URL.
buffer : l'endroit où stocker les données reçu.
length : l'endroit où stocker la quantité des données reçu.
response : l'endroit où stocker la dernière réponse du serveur HTTP(ou NULL)
Returns : TRUE si tout se déroule bien, FALSE sinon.

II-G. Les objets de connexion TCP

Un GConn représente une connexion TCP. Les fonctions qui agissent sur les objets de connexion TCP sont exactement les même que celles de objets de connexion HTTP à part le nom qui diffère, on ôte le http, pour des raisons évidentes, nous ne reverrons pas ces fonctions, nous nous contenterons des fonctions en plus et des fonctions qui diffère.

II-G-1. Créer un objet de connexion TCP

Il éxiste trois fonction :


// Ressemblant à gnet_conn_http_new à la diffèrence des arguments, que l'on reconnait tout de même sans peine
GConn* gnet_conn_new(const gchar *hostname, gint port, GConnFunc func, gpointer user_data);

// Fonction permettant de remplacer le port et le serveur par une GInetAddr
GConn* gnet_conn_new_inetaddr(const GInetAddr *inetaddr, GConnFunc func, gpointer user_data);

// Créé un objet de connexion TCP à parti d'une socket TCP
GConn* gnet_conn_new_socket(GTcpSocket *socket, GConnFunc func, gpointer user_data);

Je ne pense pas que plus d'explications soient nécessaire.

II-G-2. Suppression et référence

Ce système de référence/déréférence commun à tous les objets de la librairie est symbolisé par ces deux fonctions :


// Ajoute une référence
void gnet_conn_ref(GConn *conn);

// Ote une référence
void gnet_conn_unref(GConn *conn);

Tachez cependant de ne pas oublier que lorsque le nombre de référence à un objet atteint zéro, cet objet est détruit.
Pour la suppression, vous deviez l'avoir devinez, c'est cette fonction :


void gnet_conn_delete(GConn *conn);

Cela supprime tout bêtement l'objet de connexion donné en argument.

II-G-3. gnet_conn_set_callback()

Cette fonction :


void gnet_conn_set_callback(GConn *conn, GConnFunc func, gpointer user_data);

Permet de définir la fonction callback de l'objet de connexion passé en argument, la fonction callback est appelé au moindre événement.
Comme toujours il faut créer une fonction avec ce prototype :


void user_fonction(GConn *conn, GConnEvent *event, gpointer user_data);

Puis un pointeur sur cette fonction comme ceci :


void (*GConnFunc) (GConn *conn, GConnEvent *event, gpointer user_data);

pour le deuxième argument(l'événement de la fonction), vous avez le choix parmis ces evénements :

GNET_CONN_ERROR: Erreur, la connexion est fermé.
GNET_CONN_CONNECT: Complément de gnet_conn_connect().
GNET_CONN_CLOSE: La connexion à été fermée. Cet evénement ne peut pas être le résultat de gnet_conn_disconnect(), gnet_conn_unref(), ni de gnet_conn_delete().
GNET_CONN_TIMEOUT: Le temps de vie défini avec gnet_conn_timeout() dépassé.
GNET_CONN_READ: La donnée n'a pas été lu. Cet evénement peut provenir de calling gnet_conn_read(), gnet_conn_readn(), ou de gnet_conn_readline().
GNET_CONN_WRITE: La donnée à été écrite. Cet evénement peut être le résultat de la fonction gnet_conn_write().
GNET_CONN_READABLE: La connexion est disponible en lecture.
GNET_CONN_WRITABLE: La connexion est disponible en écriture.

IIoilà, pas la peine d'en dire plus me semble t-il.

II-G-4. gnet_conn_connect(), gnet_conn_disconnect() et gnet_conn_is_connected()

Ces deux fonctions :


void gnet_conn_connect(GConn *conn);
void gnet_conn_disconnect(GConn *conn);

Permettent respectIIement d'établir et de stoper la connexion du GConHttp passé en argument.
Quant à la fonction :


gboolean gnet_conn_is_connected(const GConn *conn);

Elle renvoie TRUE si la connexion est établie, FALSE sinon.

II-G-5. Lecture/Ecriture

II-G-5-a. Lecture

Pour la lecture, nous avons ces trois fonctions :


void gnet_conn_read(GConn *conn);
void gnet_conn_readn(GConn *conn, gint length);
void gnet_conn_readline(GConn *conn);

Qui permettent respectIIement :

De commencer une lecture asynchrone, la fonction callback est appelé lorsque des données sont lues.
De commencer une lecture asynchrone d'exactement le nombre d'octet donnée en argument. La fonction callback est aussi appelée lorsque des données sont lues.
De commencer une lecture de ligne asynchrone. La fonction callback et là-aussi appelée lorsque des données sont lues. Une ligne se termine pas \n, \r, \r\n, ou \0.

II-G-5-b. Ecriture

Pour cela, il n'éxiste qu'une seul fonction :


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

Ecris le contenu du buffer(de manière asynchrone), le buffer est copié, il peut arrIIer qu'il soit effacé. length représente la taille de ce qui sera écrit.

II-G-6. gnet_conn_set_watch_error()

Cette fonction :


void gnet_conn_set_watch_error(GConn *conn, gboolean enable);

Permet d'actIIer/désactIIer l'évenement GNET_CONN_ERROR pour le GConn passé en argument.

II-G-7. gnet_conn_set_watch_writable() et gnet_conn_set_watch_readable()

II-G-7-a. gnet_conn_set_watch_writable()

Cette fonction dont voici le prototype :


void gnet_conn_set_watch_writable(GConn *conn, gboolean enable);

Permet d'actIIer/désactIIer l'evénement GNET_CONN_WRITABLE pour le GConn passé en argument.

II-G-7-b. gnet_conn_set_watch_readable()

Cette fonction :


void gnet_conn_set_watch_readable(GConn *conn, gboolean enable);

Permet d'actIIer/désactIIer l'evénement GNET_CONN_READABLE pour le GConn passé en argument.

II-G-8. gnet_conn_timeout()

Cette fonction dont voici le prototype :


void gnet_conn_timeout(GConn *conn, guint timeout);

Permet de définir un temps de vie d'un GConn, une fois ce temps dépassé, l'evénement GNET_CONN_STATUS_TIMEOUT est enclenché.

II-H. Les Serveurs TCP

Bénis soit GNet ! Pour les Serveurs TCP, GNet nous propose les GServer. Les GServer sont en faîtes des encapsulations des socket TCP-serveurs(revoir ceci en cas de doutes).

II-H-1. Créer un Serveurs TCP

Pour créer un serveur TCP, on dispose de cette fonction :


GServer* gnet_server_new(const GInetAddr *iface, gint port, GServerFunc func, gpointer user_data);

Revenons donc de plus près sur cette fonction :

iface : interface à laquelle lié le Serveur TCP(NULL pour un serveur lié à toutes les interfaces.
port : port de connexion(0 pour un port arbitraire.
func : fonction callback.
user_data : donnée quelconque à passé à la fonction callback.
Renvoies : un pointeur sur un GServer.

Le système de fonction callback ne devrait plus vous êtres inconnu, pour cette raison, nous ne reviendrons pas dessus de manière précise, vous devez d'abord créer une fonction callback respectant ce prototype :


void user_fonction(GServer *server, GConn *conn, gpointer user_data)

Puis un pointeur sur cette fonction :


void (*GServerFunc) (GServer *server, GConn *conn, gpointer user_data);

IIOus devrez ensuite donner ce pointeur à la fonction.

II-H-2. Rédrence et déréference

Comme pour les autres objets, ces deux fonctions éxistent :


// Ajoute une référence
void gnet_server_ref(GServer *server);

// Enléve une référence
void gnet_server_ref(GServer *server);

Sans oublier de prendre en compte le fait que lorsque le nombre de référence à un objet atteint 0, l'objet est détruit.

II-H-3. Suppression d'un GServer

Pour supprimer un GServer, il y a cette fonction :


void gnet_server_delete(GServer *server);

Rien à dire de plus.

II-I. Les IOChannels

Il reste un détail dont je n'ai pas parlé, les IOChannels, litérralement canaux d'entrées/sorties, GNet fourni les GIOChannel.

II-I-1. Recupérer les IOChannel

Certains des objets que nous avons fut possédent des IOChannel, ces objets sont :

TCP - TCP socket
UDP - UDP socket
Mcast - IP Multicast socket

Pour récupérer l'IOChannel de ces objets, procédés avec cet fonction :


gnet_objet_get_io_channel(Objet* objet);

En l'adaptant biensur à votre objet, et en récupérant la valeur de retour dans un pointeur de type GIOChannel.

II-I-2. Utiliser un GIOChannel

Il n'y a que 4 fonctions :


GIOError gnet_io_channel_writen(GIOChannel *channel, gpointer buffer, gsize length, gsize *bytes_writtenp);
GIOError gnet_io_channel_readn(GIOChannel *channel, gpointer buffer, gsize length, gsize *bytes_readp);
GIOError gnet_io_channel_readline(GIOChannel *channel, gchar *buffer, gsize length, gsize *bytes_readp);
GIOError gnet_io_channel_readline_strdup(GIOChannel *channel, gchar **bufferp, gsize *bytes_readp);

Ces fonctions renvoies toutes un type d'erreur sur lequel nous reviendrons, elles permettent respectIIement :

D'écrire le nombre d'octet donné en argument en provenance du buffer lui aussi donnée en argument. Le type du buffer peut être quelconque. Cette fonction est en partie une encapsulation de la fonction g_io_channel_write().
De lire le nombre d'octet donné en argument que l'on stcokera dans buffer. Cette fonction est elle aussi une encapsulation de la fonction g_io_channel_read().
De lire une ligne qui sera stocké dans le buffer. La ligne finira par NULL et le caractère de fin de ligne sera inclu. Si le buffer est trop petit, la ligne est tronqué purement et simplement.
Attention :
1. Si le buffer est plein et que le caractère suivant n'est pas le caractère de fin de ligne, la ligne sera tronqué sans le caractère de fin de ligne.
2. L'argument bytes_readp représentant le nombre de caractère à lire doit inclure le caractère NULL.
De lire une ligne mais en vérifiant la taille du buffer donné en argument, si la taille ne correspond pas, le buffer désallocé et subis une autre allocation mémoire.
Attention :
1. De même si le buffer est trop petit, la ligne est tronqué et finis par EOF
2. Là aussi le nombre de caractères doit inclure le caractère NULL.

Aucune précision supplémentaire ne me semble nécessaire.

II-J. Les URI(Uniforme Ressource Identifier)

Si vous avez été déstabilisé en voyant URI au cour de ce tutoriel, ce paragraphe est pour vous.

II-J-1. Créer un URI

Il arrIIe que certaines fonctions prennent un URI en paramètre, c'est pourquoi nous alons étudier la création d'URI, il y a pour cela trois fonctions.

II-J-1-a. gnet_uri_new()

Cette fonction :


GURI* gnet_uri_new(const gchar *uri);

Permet de créer une URI à partir de la chaîne de caractère donné en argument, cette fonction ne vérifie par la validitée de l'URI, une URI est la plupart du temps de la forme :


type://infouserhostname:port/path?var

Cette fonction renvoie un pointeur sur une GURI ou NULL en cas d'erreur.

II-J-1-b. gnet_uri_new_fields()

Si la fonction précédente vous fait peur et que vous avez peur de vous trompez, cette fonction est pour vous :


GURI* gnet_uri_new_fields(const gchar *type, const gchar *hostname, const gint port, const gchar *path);

Cette fonction permet d'utiliser les champs les plus répendus, pour une fonction complète, utilisez gnet_uri_new_fields_all().

II-J-1-c. gnet_uri_new_fields_all()

Cette fonction :


GURI* gnet_uri_new_fields_all(const gchar *scheme, const gchar *userinfo, const gchar *hostname, const gint port, const gchar *path, const gchar *query, const gchar *fragment);

Permet de créer une URI complète, la différence avec la fonction gnet_uri_new(), est que cette fonction permet de découper les différents morceaux pour mieu s'y retrouver.

II-J-2. Gestion des URI

GNet nous propose une multitude de fonction dIIers et varier pour gérer les URI(pas moins de 12), c'est ces fonctions que nous allons étudier ici.

II-J-2-a. gnet_uri_clone()

Cette fonction :


GURI* gnet_uri_clone(const GURI *uri);

Permet de cloner le GURI passé en argument et de le renvoyer vous pouvez ensuite le récupérer, ce qui permet au final de le cloner, cette fonction est défini très simplement :


GURI* gnet_uri_clone(cont GURI *uri)
{
 return uri;
}

II-J-2-b. gnet_uri_escape()

Cette fonction :


void gnet_uri_escape(GURI *uri);

Permet d'échapper l'URI passé en argument, les protooles internet utilisent les URI echappé, les utilisateurs utilisent les URI non-échappé.

II-J-2-c. gnet_uri_unescape()

Et son opposé :


void gnet_uri_unescape(GURI *uri);

Permet de déséchapper l'URI passé en argument.

II-J-2-d. gnet_uri_get_string()

Cette fonction quant à elle :


gchar*  gnet_uri_get_string(const GURI *uri);

Permet de récupérer l'URI sous forme de chaîne de caractères. N'oubliez pas d'échapper ou de déséchapper avant d'appeler cette fonction.

II-J-2-e. gnet_uri_set_scheme()

Cette fonction :


void gnet_uri_set_scheme(GURI *uri, const gchar *scheme);

Permet de définir le protocole.

II-J-2-f. gnet_uri_set_userinfo()

Cette fonction :


void gnet_uri_set_userinfo(GURI *uri, const gchar *userinfo);

Permet de définir les informations sur l'utilisateur.

II-J-2-g. gnet_uri_set_hostname()

Cette fonction dont voici le prototype :


void gnet_uri_set_hostname(GURI *uri, const gchar *hostname);

Permet de définir l'hôte.

II-J-2-h. gnet_uri_set_port()

Cette fonction


void gnet_uri_set_port(GURI *uri, gint port);

Permet de définir le port du GURI passé en argument.

II-J-2-i. gnet_uri_set_path()

Cette fonction :


void  gnet_uri_set_path(GURI *uri, const gchar *path);

Permet de définir le path du GURI passé en argument.

II-J-2-j. gnet_uri_set_query()

Cette fonction dont voici le prototype :


void gnet_uri_set_query(GURI *uri, const gchar *query);

Permet de définir les ? pour passer les variables(PHP notamment) dans l'adresse.

II-J-2-k. gnet_uri_set_fragment()

Cette fonction :


void gnet_uri_set_fragment(GURI *uri, const gchar *fragment);

Permet de définir les variables qui sont passés dans l'adresse(donc avec la méthode GET).

II-J-2-l. gnet_uri_equal()

Cette fonction dont voici le prototype :


gboolean gnet_uri_equal(gconstpointer p1, gconstpointer p2);

Renvoie TRUE si les deux pointeurs sont équIIalents, FALSE sinon.

II-K. Base64

GNet nous offre deux fonctions, une d'encodage et de décodage.

II-K-1. gnet_base64_encode()

Cette fonction :


gchar* gnet_base64_encode(gchar *src, gint srclen, gint *dstlenp, gboolean strict);

Permet d'encoder une chaîne de caractère vers une représentation base64, mettez le 4éme argument à TRUE si vous voulez qu'un caractère de fin de ligne soit inséré tous les 72 caractères, c'est requis par le réglement RFC 2045, mais beaucoup d'application ne le demande pas.

II-K-2. gnet_base64_decode()

Cette fonction :


gchar* gnet_base64_decode(gchar *src, gint srclen, gint *dstlenp);

Permet de décoder une chaîne de caractère à partir d'une représentation base64 vers une représentation binaire.

Précédent Sommaire Suivant

Version PDF (Miroir) Version hors-ligne (Miroir)

Copyright © 2000-2005 Hugo Stephan Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions. Read the full licence here : http://gnetlibrary.org/docs