Show Menu
Cheatography
  1. Home >
  2. Cheat Sheets >

C Programmation de Socket Cheat Sheet (DRAFT) by

This is a draft cheat sheet. It is a work in progress and is not finished yet.

Socket Client (TCP)

En mode connecté (TCP) la socket doit être branchée de manière explicite à la partie distante pendant toute la durée des échanges de messages.
> Demande de connextion pour le client : connect()
> Attente de connnexion pour le serveur : listen() puis accept

Socket serveur (TCP)

Création de socket

int socket (int domaine, int type, int protoc­ole);
 
int domaine
AF_UNIX ou AF_INET ou PF_INET
 
int type
SOCK_DGRAM ou SOCK_S­TREAM
 
int protocole
0: protocol par défaut (UDP ou TCP)
 
INADDR_ANY
addresse de la machine
 
AF_INET
Address Family, Internet = IP Addresses
 
PF_INET
Protocol Family, Internet = IP, TCP/IP or UDP/IP
 
AF_UNIX = AF_LOCAL
commun­ication entre processsus au sein d'une même machine
 
SOCK_S­TREAM
pour sockets orientés stream
Côté client nous devons config­urer: la partie local et la partie qui sera connecté au serveur

Attach­ement socket

int bind ( 
 int descri­pteur, 
 struct sockaddr* adr, 
 int longueurAdr
);

descripteur
point -> adr attachement
long. adr en octets
 
long inet_addr (const char* adrIP)

Config­uration de socket

struct in_addr { 
 u_long s_addr;
 };
Add IP de la machine
 
struct sockad­dr_in { 
 short sin_family;
u_short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
};
Addr d'1 socket
AF_INT
num port
adr IP
champ de 8 '\0'
EXEMPLE D'ATTA­CHEMENT
//Decl­aration
struct sockad­dr_in adrLocale;

//Conf­igu­ration
 
 memset­((char)&­adr­Loc­ale­,'­\0',­siz­eof­(struct sockad­dr_­in)); 
adrLocale.sin_family = AF_INET; 
adrLocale.sin_addr.s_addr = htonl(INADDR_ANY);
adrLocale.sin_port = htons(numPort);
bind(descripteur, (struct sockaddr) &a­drL­ocale, sizeof­(struct sockad­dr));

Fonctions d'util­isation de socket

int connect ( 
 descripteurSocket,
 &adrServeur,
 longueur_adr
);
même prototye que bind
int descripteurSocket
struct sockaddr* adrServeur
int longue­ur_adr
 
int listen (
descSocketEcoute,
nbPendantes
);

int descripteurSocketEcoute
int nbMax de connexions pendantes
 
int accept(
descSockEcoute, 
&servStore,
longueurAdr
);

int descripteurSockEcoute
struct sockaddr* servStore
int longue­urAdr
 
int send = ( 
descripteurSocket, 
message, 
strlen(message), 
option
);

int descripterSocket
char message[]
int longueurMessage
0
 
int recv ( 
descripteurSocket, 
message, 
strlen(message), 
option
);

int descripterSocket
char message[]
int longueurMaxiMsg
0
 
int shutdown(
descripteurSocket, 
sens
);

int descSocket
0: lect; 1:ecrit; 2: les deux
 
int close(int descri­teur);

Inclusions biblio­thèques nécess­aires

#include <sy­s/s­ock­et.h­>
socket() et bind()
 
#include <ne­tin­et/­in.h­>
in_addr et sockad­dr_in
 
#include <ar­pa/­ine­t.h>
htonl, htons,­ine­t_addr
 
#include <un­ist­d.h>
close()
 
#include <st­dio.h>
 
#include <st­dli­b.h>
 
#include <st­rin­g.h>
 
#include <sy­s/t­ype­s.h>
 
#include <ne­tdb.h>

Fonctions de conversion

uint32_t htonl(­uin­t32_t hostlong);
host to network long
 
uint16_t htons(­uin­t16_t hostsh­ort);
host to network short
 
uint32_t ntohl(­uin­t32_t netlong);
network to host long
 
uint16_t ntohs(­uin­t16_t netshort);
network to host short

Specif­icateur de type lors de printf ou scanf

%d
int
%s
string
%c
char
%f
float
%p
pointer
%u
unsigned int
 

Squelette Client

int main(){
//DECLARATION VARIABLES
int clientSocket, connexion, reception, envoie, deconnexion;
struct sockaddr_in serverAddr;
struct sockaddr_in localAddr;
socklen_t addr_size;
char requete[] = "test";
char reponse[1024];
long port = 10500;
long ip = inet_addr("193.50.225.215");

//TRAITEMENT
    
// Création de la socket
printf("Creation de la socket.....\n");
clientSocket = socket(PF_INET, SOCK_STREAM, 0); 
    
// Configuration des parametres de ma struct de l'addresse locale
printf("Configuration de la struct d'addresse locale\n");
memset(localAddr.sin_zero, '\0', sizeof(localAddr.sin_zero));   
localAddr.sin_family = AF_INET; 
localAddr.sin_port = htons(0); //port locale
localAddr.sin_addr.s_addr = htonl (INADDR_ANY); //Adr. locale
bind(clientSocket, (struct sockaddr) &localAddr, sizeof(struct sockaddr)); //Association IP et port*

// Configuration des parametres de la struct de l'addresse du serveur 
printf("Configuration de la struct d'addresse serveur\n");
memset(serverAddr.sin_zero, '\0', sizeof(serverAddr.sin_zero));   
serverAddr.sin_family = AF_INET;  
serverAddr.sin_port = htons(port); //port du serveur
serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");  // Adr. du serveur

//Connexion du serveur
addr_size = sizeof serverAddr; 
connect(clientSocket, (struct sockaddr *) &serverAddr, 

//Boucle de communication avec le serveur
while(!fini) {
   //Envoie de la requete au serveur
    send(clientSocket, requete, strlen(requete), 0);
   //Attente de la réponse du serveur
    recv(clientSocket, reponse, strlen(reponse), 0);
}
  // Deconnexion et fermeture de la socket
  shutdown(clientSocket, 2);
  close(clientSocket);

  return 0;
}

Squelette serveur

int main(){
  
//DECLARATION 
int socketEcoute, socketService, attachement, connexion, reception, envoie, deconnexion, fermeture;
int dialogueClient = 1;
char reponse[1024];
struct sockaddr_in serverAddr;
struct sockaddr_storage serverStorage;
socklen_t addr_size;
long port = 10500;
  
//TRAITEMENT
// Creation de la socket ecoute
printf("Creation de socketEcoute.....\n");
socketEcoute = socket(PF_INET, SOCK_STREAM, 0); 

// Configuration des parametres de la struct de l'addresse du serveur 
memset(serverAddr.sin_zero, '\0', sizeof serverAddr.sin_zero);  
serverAddr.sin_family = AF_INET; 
serverAddr.sin_port = htons(port);
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);  


//Attachement
printf("Attachement de socketEcoute....\n");
attachement = bind(socketEcoute, (struct sockaddr *) &serverAddr, sizeof(serverAddr));
  
//Mise à l'ecoute (maxi 5 connections)
if(listen(socketEcoute,5)==0)
  printf("Mise a l'ecoute.....\n\n");
else
    printf("Erreur de mise a l'ecoute\n\n");

//Attente connexion
while(1) {
addr_size = sizeof serverStorage;
socketService = accept(socketEcoute, (struct sockaddr *) &serverStorage, &addr_size); 
  
//Dialogue avec le client
while(1) {
//Lecture de la requete du client

//Envoie de la reponse au client
}
// Terminaison et fermeture socket de service 
shutdown(socketService, 2);
}
//Fermeture de la socket d'écoute
close(socketService);

  return 0;
}

Fonctions en C

memset­(char* chaine, char car, int n)
Retourne la chaine avec char au debut n fois
 
int touppe­r(s­tr[i])
Mettre le car en param. en majuscule
 
int tolowe­r(s­tr[i])
Mettre le car en param. en minuscule
 
int strlen­(str)
retourne longueur de la chaîne
 
int strcmp­(str1, str2)
Valeurs de retours:
< 0 si str1 < str2
> 0 si str1 > str2
= 0 si str1== str2
 
strcpy­(st­r1,­str2)
Copier contenu de str2 dan str1
Exemple de fonction en c:
int cherch­erI­nde­xCa­r(char car, char jeu[], int tailleJeu) { 
 int colonne = -1;
int c = 0;
while(c < tailleJeu) {v
if (jeu[c] == car) {
 colonne = c;
 break;
}
c++;
} 
return colonne; 
}

Exemple d'appel de fonction en c:
int index = cherch­erI­nde­xCa­r(c­her­che­rIn­dex­Car­(car, jeu, nbLign­es*­nbC­olo­nnes);

Fonctions, Procédures et passage de paramètre

void proc(char chaine[]) {...}
chaine est passé par addresse
 
void proc(int num) {...}
num est passé par valeur
 
void proc(int *num) {...}
num est passé par addresse
 
Declar­ation
void affich­er(int lignes, int colonnes, char chaine[][colonnes]){...}
char morpion[3][3];
Appel
afficher(3, 3, morpion);
 
Fonction d'affi­chage de tableau di-dim:
void affich­er(int lignes, int colonnes, char chaine­[][­col­onnes]) { 
int i = 0;
int j = 0;
while (i < lignes) {
while (j < colonnes) {
printf("%c", chaine[i][j]);
j++;
}
printf("\n");
i++;
 j = 0;
}
}