public String[][] recupAllData(){ 
       String[] tabData= new String[3]; 
       tabData[0]=argument1; 
       tabData[1]=argument2; 
       tabData[2]=argument3; 
       try{ 
   //connexion à la servlet 
            URL urlServlet=new URL("http://monServeur/monSite/servlet/getData"); 
          URLConnection connexion=urlServlet.openConnection(); 
            connexion.setDoOutput(true); 
         //sortie des données vers la servlet 
            ObjectOutputStream sortieObjet= new ObjectOutputStream(connexion.getOutputStream()); 
            sortieObjet.writeObject(tabData); 
         //retour de données en provenance de la servlet 
            ObjectInputStream entreeObjet= new ObjectInputStream(connexion.getInputStream()); 
            return (String[][])entreeObjet.readObject(); 
       }catch(Exception e){ 
          zoneMessage.reEcris(msgErr2); 
            System.out.println(e.toString()); 
            return null; 
       } 
     }

public void doPost(HttpServletRequest requete,HttpServletResponse reponse){ 
          
      try{ 

           
           sortieObjet= new ObjectOutputStream(reponse.getOutputStream()); 
          entreeObjet= new ObjectInputStream(requete.getInputStream()); 
          String[][] monTableauResultat; 
          /*************************récupération des données de l'applet */
          lesDonnees=(String[])entreeObjet.readObject(); 

         /*************************on pose la question à la base de données */                
          requeteSql= "SELECT nom, prenom, mail from maTable "+
                            " where arg1='"+lesDonnes[0]+"' "+
                           " and arg2='"+lesDonnes[1]+"' and arg3='"+lesDonnes[2]+"' ";       
    
/** on pose la question à la base de données 
je vous montre pas le bout de code qui pond la réponse 
*/

                     
          /******************************renvoi du tableau de résultat */
          sortieObjet.writeObject(monTableauResultat); 
             
      }catch(Exception e){ 
         System.out.println(" ERR >> getData :"+e); 
      } 
   }

Client Java
try {

             InetAddress addresse = InetAddress.getLocalHost();
            
            
             Socket socket = new Socket(addresse, 6001);
             System.out.println("SOCKET = " + socket);
            
                    
             OutputStream os = socket.getOutputStream();
             System.out.println("JAVA ecriture du buf");
             os.write("Edit".getBytes());

             System.out.println(" JAVA fin ecriture du buf");
            
                   
 catch (IOException exc) {
            System.err.println(exc.getMessage());
             }

Serveur C++
/*liste des imports*/
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <iostream.h>
#include <unistd.h>
#define SADDR struct sockaddr * 

// ...

struct sockaddr_in sa;
      int s, i, n = sizeof(sa);
      if ((s=socket(AF_INET,SOCK_STREAM,0)) < 0) throw(3);//make socket
     sa.sin_family = AF_INET;                             // set type
     sa.sin_addr.s_addr = INADDR_ANY;             // set wildcard
     sa.sin_port = htons(6001);                           // set port
          if ( bind(s, (struct sockaddr*)&sa, n) < 0 ) throw(3);         // bind address
          if(listen(s,1)<0)
       {
                  throw(3);
       }

int connected_fd;
        int rlen = sizeof(sa);

        if( (connected_fd=accept(s,(struct sockaddr*)&sa,&rlen))<0){
               throw(3);
       }

      
      printf("C++ la valeur du connected est %i \n",connected_fd);
      
       char buf[512];
        
                 int nbrecv = recv(connected_fd,buf,512,0);
         if(nbrecv <0){perror("recv");}
         //cont = (nbrecv > 0);
                 
         cout << "C++ Message: " << buf << endl; 
                  close(connected_fd);

//Envoi un message provenant de no-reply@societe.fr au webmaster,
//à mail@exemple et no.spam
Mail m = new Mail();
m.setTo("webmaster, mail@exemple.com;no.spam@thank.you");
m.setSujet("test");
m.setMessage("Ceci est un test");
m.send();

/*
 * Created on 10 nov. 2004
 */
package xxxx.util;

import java.util.Properties;

import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

/**
 * Classe pour simplifier les envois de mails
 * @author SMAC
 */
public class Mail {
   /** Type texte brut */
   static public final int TEXT = 0;
   /** Type text/html */
   static public final int HTML = 1;
   
   /** Adresse "no-reply" par défaut de l'entreprise */
   private static final String NOREPLY = "noreply@societe.fr";
   /** Adresse du serveur SMTP de l'entreprise */
   private static final String SMTPHOST = "smtp.societe.fr";
   
   private Properties props;
   private Session session;
   private MimeMessage mm;
   private int mimetype;
   /**
    * Si on n'appelle pas setFrom, met automatiquement noreply@societe.fr
    */
   private boolean noreply = true;
   
   /**
    * Créateur d'un mail.
    */
   public Mail() {
      //Par défaut en texte brut
      mimetype = TEXT;
      
      //Get system properties
      props = System.getProperties();
      //Setup mail server
      props.put("mail.smtp.host", SMTPHOST);
      //Get session
      session = Session.getDefaultInstance(props, null);
      //Define message
      mm = new MimeMessage(session);
   }
      
   //############################################################
   //Ajout d'expéditeur et destinataires
   //############################################################
   
   /**
    * Ajoute un expéditeur
    * @param expediteur
    * @throws Exception
    */
   public void setFrom(String expediteur) throws Exception {
      if (expediteur.trim().length() > 0) {
         mm.setFrom(checkMail(expediteur));
         noreply = false;
      }
   }
   
   /**
    * Ajoute un destinataire
    * @param destinataire
    * @throws Exception
    */
   public void setTo(String destinataire) throws Exception {
      if (destinataire.trim().length() > 0) {
         if (plusieursMails(destinataire))
            setTo(decoupe(destinataire));
         else {
            mm.addRecipient(Message.RecipientType.TO, checkMail(destinataire));
         }
      }
   }
   /**
    * Ajoute plusieurs destinataires
    * @param dest
    * @throws Exception
    */
   public void setTo(String[] dest) throws Exception {
      for (int i=0; i<dest.length; i++)
         setTo(dest[i]);
   }
   
   /**
    * Ajoute un destinataire en copie
    * @param cc
    * @throws Exception
    */
   public void setCC(String cc) throws Exception {
      if (cc.trim().length() > 0) {
         if (plusieursMails(cc))
            setCC(decoupe(cc));
         else {
            mm.addRecipient(Message.RecipientType.CC, checkMail(cc));
         }
      }
   }
   /**
    * Ajoute plusieurs destinataires en copie
    * @param cc
    * @throws Exception
    */
   public void setCC(String[] cc) throws Exception {
      for (int i=0; i < cc.length; i++)
         setCC(cc[i]);
   }
   
   /**
    * Ajoute un destinataire en copie cachée.
    * @param bcc
    * @throws Exception
    */
   public void setCopieCachee(String bcc) throws Exception {
      if (bcc.trim().length() > 0) {
         if (plusieursMails(bcc))
            setCopieCachee(decoupe(bcc));
         else {
            mm.addRecipient(Message.RecipientType.BCC, checkMail(bcc));
         }
      }
   }
   /**
    * Ajoute plusieurs destinataires en copie cachée.
    * @param bcc
    * @throws Exception
    */
   public void setCopieCachee(String[] bcc) throws Exception {
      for (int i=0; i < bcc.length; i++)
         setCopieCachee(bcc[i]);
   }
   
   //############################################################
   //Champs avec destinataires multiples
   //############################################################

   /**
    * Teste si y'a plusieurs mails dans la chaîne, séparés par un espace, une virgule ou un point-virgule
    * @param mails
    * @return
    */
   static public boolean plusieursMails(String mails) {
      return ((mails.indexOf(' ') + mails.indexOf(',') + mails.indexOf(';')) > -1);
   }
   /**
    * Découpe la chaîne contenant plusieurs mails en String[]
    * @return
    */
   static public String[] decoupe(String mails) {
      return mails.split(" |,|;");
   }
   
   //############################################################
   //Sujet et message
   //############################################################

   /**
    * Ajoute le sujet
    * @param sujet
    * @throws Exception
    */
   public void setSujet(String sujet) throws Exception {
      mm.setSubject(sujet);
   }
   
   /**
    * Choisir entre le type texte brut ({@link Mail#TEXT}) ou HTML ({@link Mail#HTML}).
    * @param mime
    * @throws Exception
    */
   public void setMimeType(int mime) throws Exception {
      mimetype = mime;
   }
   
   /**
    * Ajoute le message
    * @param message
    * @throws Exception
    */
   public void setMessage(String message) throws Exception {
      if (mimetype == HTML)
         mm.setContent(message, "text/html");
      else mm.setText(message);
   }
   
   //############################################################
   //Envoi
   //############################################################
   
   /**
    * Envoie le mail
    * @throws Exception
    */
   public void send() throws Exception {
      if (noreply)
         setFrom(NOREPLY);
      Transport.send(mm);
   }
   
   //############################################################
   //Vérifications de la validité d'adresse e-mails
   //(fonctions pour l'extérieur : jsp ou WebServices...)
   //############################################################
   /**
    * Vérifie si l'adresse passée en paramètre est valide. Si elle ne contient pas
    * de @, vérifie si elle correspond bien à un pseudo (voir nameToMail).
    * @param mail
    */
   static public void isValide(String mail) throws Exception {
      if (plusieursMails(mail))
         areValide(decoupe(mail));
      else
         Mail.checkMail(mail);
   }
   /**
    * Vérifie si les adresses passées en paramètres sont valides. Si elles ne contient pas
    * de @, vérifie si elles correspondent à des pseudos (voir nameToMail).
    * <p>Vérifie chacune des adresse, et renvoie une exception global, contenant plusieurs
    * messages d'erreur si plusieurs adresses sont fausses, chaque message étant séparé
    * par un \n.
    * @param mails
    * @throws Exception
    */
   static public void areValide(String[] mails) throws Exception {
      String msg = "";
      for (int i=0; i<mails.length; i++) {
         try {
            isValide(mails[i]);
         } catch (Exception e) {
            msg += ((msg.length()>0)?"\n":"") + e.getMessage();
         }
      }
      if (msg.length() > 0) {
         throw new Exception(msg);
      }
   }
   
   //############################################################
   //Fonctions private,
   //statiques pour être appelés par les public isValide et areValide
   //############################################################

   /**
    * Vérifie la validité d'une adresse e-mail, et renvoie sous forme d'InternetAdress
    * ou une exception en cas d'erreur.
    * @param mail
    * @throws Exception
    */
   static private InternetAddress checkMail(String mail) throws Exception {
      //Pas de @, c'est peut-être un pseudonyme ?...
      if (mail.indexOf('@') == -1) {
         return new InternetAddress(nameToMail(mail));
      }
      else {
         //le parse d'InternetAddress ne renvoie pas d'erreur sur adresse@mail
         //alors on fait un test simple pour savoir si y'a un point, après l'@
         //adresse@mail.fr est OK, adresse@mail renvoie une exception.
         if (mail.lastIndexOf('.') < mail.indexOf('@')) {
            throw new Exception("Adresse email \""+mail+"\" invalide");
         }
         else {
            return new InternetAddress(mail);
         }
      }
   }
   
   /**
    * Ici votre fonction perso, qui transforme des noms génériques en adresses e-mail.
    * <p>Par exemple : webmaster -> webmaster@societe.fr
    * @param name
    * @throws Exception si le pseudo est inconnu.
    */
   static private String nameToMail(String name) throws Exception {
      //L'exemple du mail au webmaster, si on met juste "webmaster" sans mettre
      //@societe.fr, cette fonction transforme.
      if (name.equalsIgnoreCase("webmaster"))
         return "webmaster@societe.fr";
      //else if....
      //else if....
      //else c'est une erreur
      else
         throw new Exception("Nom \""+name+"\" inconnu");
   }
}