Generer un html en c++

zimeau, le mardi 11 septembre 2007 à 00:00:03

bonjour a tous. voila, je travail sous c++ builder 6, et j'aimerai creer un petit logicielle tout simple qui, une fois lancé, genererai un fichier html sur lequelle sera inscri mon adresse ip. quelqu'un aurai quelque piste a me donné pour que je realise cela? j'ai quelque notion en c++ avec le builder, je devrai etre capable de recuperer mon ip sans probleme, mon soucis est plutot de l'envoyé dans un fichier html... merci de votre aide!

Configuration: Windows XP
Firefox 2.0.0.6

Répondre à zimeau Signaler ce message aux modérateurs Aller au dernier message

Ce message vous semble utile, votez !
Signaler ce message aux modérateurs

mamiemando, le mardi 11 septembre 2007 à 10:22:00

Ce n'est pas plus compliqué que de générer un fichier texte classique. Je te donne une version un peu "brute de fonderie". En fait il faudra probablement que tu stockes le résultat de la commande qui te donne tes informations dans un fichier temporaire le temps de le remettre en forme, que tu lises ce fichier, et que tu reporte son contenu mis en forme dans ton fichier html.

#include <fstream>
#include <cstdlib>
#include <sstream>
#include <iostream>

int main(){
    const char *filename = "plop.html";
    // Ecrire l'en tête
    {
        std::ofstream ofs(filename);
        if (ofs){
            ofs << "<html>" << std::endl
                << "<body>" << std::endl;
            ofs.close();
        }else{
            std::cerr << "ne peut pas ouvrir " << filename << std::endl;
            return 1;
        }
    }

    // Lancer la commande système
    // Sous linux /sbin/ifconfig >> plop.html
    // Sous windows ipconfig /all >> plop.html
    {
        std::ostringstream oss;
        oss << "/sbin/ifconfig >>" << filename;
        system(oss.str().c_str());
    }

    // Ecrire la fin
    {
        std::ofstream ofs(filename,std::ios_base::app);
        if (ofs){
            ofs << "</body>" << std::endl
                << "</html>" << std::endl;
            ofs.close();
        }else{
            std::cerr << "ne peut pas ouvrir " << filename << std::endl;
            return 1;
        }
    }
    return 0;
}

OPn obtiens un fichier du genre :

<html>
<body>
eth3      Lien encap:Ethernet  HWaddr 
          inet adr:192.168.1.13  Bcast:192.168.1.255  Masque:255.255.255.0
          adr inet6: fe80::208:a1ff:fe24:f9bb/64 Scope:Lien
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:3471 errors:0 dropped:0 overruns:0 frame:0
          TX packets:3713 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 lg file transmission:1000
          RX bytes:2088850 (1.9 MiB)  TX bytes:609479 (595.1 KiB)
          Interruption:201 Adresse de base:0xac00

lo        Lien encap:Boucle locale
          inet adr:127.0.0.1  Masque:255.0.0.0
          adr inet6: ::1/128 Scope:Hôte
          UP LOOPBACK RUNNING  MTU:16436  Metric:1
          RX packets:513 errors:0 dropped:0 overruns:0 frame:0
          TX packets:513 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 lg file transmission:0
          RX bytes:20011 (19.5 KiB)  TX bytes:20011 (19.5 KiB)

</body>
</html>

Bonne chance

Répondre à mamiemando

Ce message vous semble utile, votez !
Signaler ce message aux modérateurs

zimeau, le mercredi 12 septembre 2007 à 13:15:36

wahou, super, sa marche plutot bien, merci bcp :) mais serait-il possible d'isolé l'adresse ip?

Répondre à zimeau

Ce message vous semble utile, votez !
Signaler ce message aux modérateurs

mamiemando, le mercredi 12 septembre 2007 à 21:41:52

En fait ça dépend de si tu es sous windows ou linux, car la chaîne à traiter sera un peu différente (comme tu peux l'imaginer, ipconfig et /sbin/ifconfig mettent en forme le résultat différemment). Dans les deux cas la difficulté est d'isoler l'interface réseau qui nous intéresse, et ensuite d'extraire de la chaîne ladite IP. Par exemple dans <1> j'ai deux IP (192.168.1.13 pour ma carte ethernet, reliée à mon routeur, et 127.0.0.1 pour l'interface locale). J'imagine que c'est l'IP permettant de se connecter au Net qui t'intéresse (dans mon exemple il s'agira donc de 192.168.1.13).

Le problème c'est qu'il faut donc déterminer l'interface qui nous intéresse (ici eth3). Le problème c'est de trouver cette interface. Le mieux c'est d'utiliser la commande "route print" ou "/sbin/route -n" et d'extraire de la route par défaut (0.0.0.0) la fameuse interface. Ainsi sous linux :

(mando@aldur) (~) $ /sbin/route -n
Table de routage IP du noyau
Destination     Passerelle      Genmask         Indic Metric Ref    Use Iface
192.168.1.0     0.0.0.0         255.255.255.0   U     0      0        0 eth3
0.0.0.0         192.168.1.1     0.0.0.0         UG    0      0        0 eth3

La route par défaut (0.0.0.0) utilise l'interface eth3 qui a pour ip locale 192.168.1.13 (cf /sbin/ifconfig) :

(mando@aldur) (~) $ /sbin/ifconfig eth3
eth3      Lien encap:Ethernet  HWaddr
          inet adr:192.168.1.13  Bcast:192.168.1.255  Masque:255.255.255.0
          adr inet6: fe80::208:a1ff:fe24:f9bb/64 Scope:Lien
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:2621 errors:0 dropped:0 overruns:0 frame:0
          TX packets:2971 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 lg file transmission:1000
          RX bytes:1381060 (1.3 MiB)  TX bytes:354780 (346.4 KiB)
          Interruption:201 Adresse de base:0xac00

et envoie le trafic vers le routeur (192.168.1.1). Ainsi il faut :
1) Récupérer via la commande route l'interface qui nous intéresse (eth3)
2) Récupérer les informations liées à cette interface et extraire son IP (192.168.1.13)

Etant donné que le programme commence à s'allonger, j'ai décomposé en fonction. Ici je me base sur les sorties renvoyées par les commandes linux, à toi d'adapter si tu veux faire la même chose sous windows.

#include <fstream>
#include <cstdlib>
#include <sstream>
#include <iostream>
#include <string>
#include <cassert>

bool write_head(const char *filename){
    std::ofstream ofs(filename);
    if (ofs){
        ofs << "<html>" << std::endl
            << "<body>" << std::endl;
        ofs.close();
        return true;
    }else{
        std::cerr << "ne peut pas ouvrir " << filename << std::endl;
        return false;
    }
}

bool get_iface(const char *filename_tmp,std::string & iface){
    std::ostringstream oss;
    oss << "/sbin/route -n >" << filename_tmp;
    // Format :
    // Destination     Passerelle      Genmask         Indic Metric Ref    Use Iface
    // 192.168.1.0     0.0.0.0         255.255.255.0   U     0      0        0 eth3
    // 0.0.0.0         192.168.1.1     0.0.0.0         UG    0      0        0 eth3
    //
    // La route par défaut commence par "0.0.0.0 ....", donc je vais extraire ici eth3

    system(oss.str().c_str());
    std::ifstream ifs(filename_tmp);
    if(ifs){
        std::string str;
        while(getline (ifs,str)){
            if(str.find("0.0.0.0") == 0){
                std::istringstream iss(str,std::istringstream::in);
                std::string destination,passerelle,genmask,indic;
                unsigned metric,ref,use;
                iss >> destination >> passerelle >> genmask >> indic >> metric >> ref >> use >> iface;
                break;
            }
        }
    }else{
        std::cerr << "ne peut pas ouvrir " << filename_tmp << std::endl;
        return false;
    }
    std::cout << "iface = " << iface << std::endl;
    return true;
}

bool get_ip(const char *filename_tmp,const std::string & iface,std::string & ip){
    std::ostringstream oss;
    oss << "/sbin/ifconfig " << iface << " >" << filename_tmp;
    // Format:
    // eth3      Lien encap:Ethernet  HWaddr
    //           inet adr:192.168.1.13  Bcast:192.168.1.255  Masque:255.255.255.0
    //           adr inet6: fe80::208:a1ff:fe24:f9bb/64 Scope:Lien
    //           UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
    //           RX packets:2153 errors:0 dropped:0 overruns:0 frame:0
    //           TX packets:2394 errors:0 dropped:0 overruns:0 carrier:0
    //           collisions:0 lg file transmission:1000
    //           RX bytes:1323553 (1.2 MiB)  TX bytes:289997 (283.2 KiB)
    //           Interruption:201 Adresse de base:0xac00
    //
    // Dans cet exemple je vais extraire 192.168.1.13
    system(oss.str().c_str());
    std::ifstream ifs(filename_tmp);
    if(ifs){
        std::string str;
        while(getline (ifs,str)){
            // L'IP est comprise entre les mots "inet adr:" et "Bcast:"
            const std::string
                pattern_begin("inet adr:"),
                pattern_end("Bcast:");
            unsigned
                pos_begin = str.find(pattern_begin),
                pos_end   = str.find(pattern_end);
            if(pos_begin != std::string::npos && pos_end != std::string::npos){
                unsigned pos_ip = pos_begin + pattern_begin.size();
                assert(pos_begin < pos_end);
                ip = std::string(str,pos_ip,pos_end-pos_ip); // on extrait la sous-chaine
                std::istringstream iss(str,std::istringstream::in);
                break;
            }
        }
    }else{
        std::cerr << "ne peut pas ouvrir " << filename_tmp << std::endl;
        return false;
    }
    std::cout << "ip = " << ip << std::endl;
    return true;
}

bool write_tail(const char *filename,const std::string & ip){
    std::ofstream ofs(filename,std::ios_base::app);
    if (ofs){
        ofs << ip << "<br>" << std::endl
            << "</body>" << std::endl
            << "</html>" << std::endl;
        ofs.close();
    }else{
        std::cerr << "ne peut pas ouvrir " << filename << std::endl;
        return false;
    }
    return true;
}

int main(){
    const char *filename = "plop.html", *filename_tmp ="tmp.txt";
    // Ecrire l'en tête
    if(!write_head(filename)) return 1;

    // Lancer les commandes systèmes
    std::string ip;
    {
        std::string iface;
        if(!get_iface(filename_tmp,iface)) return 2;
        if(!get_ip(filename_tmp,iface,ip)) return 3;
    }

    // Ecrire la fin
    if(!write_tail(filename,ip)) return 4;
    return 0;
}

A l'exécution voilà ce que ca donne :

(mando@aldur) (~) $ g++ -W -Wall plop.cpp
(mando@aldur) (~) $ ./a.out
iface = eth3
ip = 192.168.1.13
(mando@aldur) (~) $ cat plop.html
<html>
<body>
192.168.1.13  <br>
</body>
</html>

Bonne chance

Répondre à mamiemando

Ce message vous semble utile, votez !
Signaler ce message aux modérateurs

zimeau, le jeudi 13 septembre 2007 à 11:07:47

merci! mais comme indiquer je travail sous windows... je vai recuperer le code linux et tenter de l'adapter, en esperant y arrivé... mais si on pouvais me transmettre la meme chose sous windows avec l'ipconfig, sa sera parfait! d'avance merci :)

Répondre à zimeau

Ce message vous semble utile, votez !
Signaler ce message aux modérateurs

mamiemando, le jeudi 13 septembre 2007 à 22:17:28

Désolé mais ça je ne le ferai pas car je n'ai pas de windows. Et accessoirement je préfère que tu prennes le temps de comprendre ce que j'ai fait que de le recopier bêtement. Je précise si tu as bien suivi ce que je t'ai dit que tu devras sous windows faire d'une pare
- route print
- ipconfig all
Basiquement l'idée consiste juste à stocker le résultat de ces commandes dans une fichier texte et d'en extraire l'information.

Bonne chance

Répondre à mamiemando

Ce message vous semble utile, votez !
Signaler ce message aux modérateurs

zimeau, le jeudi 13 septembre 2007 à 23:28:18

ok je vai me débrouillé alors, merci!

Répondre à zimeau

Posez votre question Répondre