[C/EPP] Uitlezen na connectie lukt niet

[RSD]

Momenteel hebben wij een simpele uitgeklede EPP client gemaakt die zo goed als
functioneert.

Enige probleem is de volgende:

Wanneer wij via SLL-> inloggen op de EPP server, krijgen wij de GREETING van de server en
kunnen we netjes uitlezen.

Vervolgens sturen wij een nieuw commando LOGIN, die ook resulteert in een response van de
server dat we zijn ingelogd.

Vervolgens ontstaat het probleem. We sturen nogmaals een bericht nadat we dus zijn
ingelogd BV. een HELLO, echter resulteert dit niet in een response. Ergens gaat daar iets
mis, connectie en SLL lijken allemaal nog in de lucht te zijn.

C:

#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <unistd.h>
#include <string.h>
#include <syslog.h>
#include <fcntl.h>

// Socket specific
int     err;
int     res;
int     sock;
struct sockaddr_in server_addr;


SSL_CTX         *ctx;
SSL* ssl = NULL;
SSL_METHOD      *meth;
BIO *sbio;

short int       s_port = 700;
const char      *s_ipaddr = "xx.xxx.xxx.xxx";
const char      *eppuser = "xxxxxx"; 
const char      *epppass = "xxxxxxxxxx"; 

char* epplogin(void);
char* epplogout(void);
char* epphello(void);
int sslconnect(void);
void sslclose(void);
char* sslsend(char *str);
void sslrecv(void);

void sslrecv(void)
{
    static char buffer[8192];
    int rc = SSL_read(ssl, buffer, 4);
    if (rc <= 0) {
        syslog(LOG_ERR, "SSL_read(4) returned error %d (ret %d, errno %d)",
               SSL_get_error(ssl, rc), rc, errno);
        long err;
        while ((err = ERR_get_error()))
            syslog(LOG_ERR, "SSL error %ld", err);
    }
    int len = (((buffer[0] & 0xff) << 24) |
               ((buffer[1] & 0xff) << 16) |
               ((buffer[2] & 0xff) << 8) |
               (buffer[3] & 0xff));
    len -= 4;
    if (len > sizeof(buffer)) {
        len = sizeof(buffer);
        syslog(LOG_DEBUG,
               "Read frame is larger than buffer. Shrinking to %d bytes", len);
    }
    rc = SSL_read(ssl, buffer, len);
    if (rc <= 0) {
        syslog(LOG_ERR, "SSL_read(%d) returned error %d",
               len, SSL_get_error(ssl, rc));
    }
    
    printf("Ontvangen bytes: %i\n",rc);
    
    buffer[sizeof(buffer)-1] = 0;
    
}


char* sslsend(char *str)
{
    
    int len = strlen(str);
    char buf[4];
    len += 4;
    buf[0] = (len & 0xff000000) >> 24;
    buf[1] = (len & 0x00ff0000) >> 16;
    buf[2] = (len & 0x0000ff00) >> 8;
    buf[3] = (len & 0x000000ff);
    int rc = SSL_write(ssl, buf, 4);
    if (rc <= 0) {
        printf("ERROR WRITE .1 !");
        syslog(LOG_ERR, "SSL_write(4) returned %d",
               SSL_get_error(ssl, rc));
        return str;
    }
    printf("Verstuurde bericht:\n\n%s\n\n",str);
    rc = SSL_write(ssl, str, len);
    if (rc <= 0) {
        syslog(LOG_ERR, "SSL_write(%d) returned %d",
               len, SSL_get_error(ssl, rc));
        printf("ERROR WRITE .2 !");
        return str;
    }
    return 0;
}

void sslclose(void)
{
    err = SSL_shutdown(ssl);
    err = close(sock);
    SSL_free(ssl);
    SSL_CTX_free(ctx);
}


int sslconnect(void)
{
#define SSL_OP_DELAY_READ_SERVER_FINISHED
    
    /* Load encryption & hashing algorithms for the SSL program */
    SSL_library_init();
    /* Load the error strings for SSL & CRYPTO APIs */
    SSL_load_error_strings();
    /* Create an SSL_METHOD structure (choose an SSL/TLS protocol version) */
    
    /* Create an SSL_CTX structure */
    sock = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);       
    memset (&server_addr, '\0', sizeof(server_addr));
    server_addr.sin_family      = AF_INET;
    server_addr.sin_port        = htons(s_port);       /* Server Port number */
    server_addr.sin_addr.s_addr = inet_addr(s_ipaddr); /* Server IP */
    /* Establish a TCP/IP connection to the SSL client */
    err = connect(sock, (struct sockaddr*) &server_addr, sizeof(server_addr)); 
    /* ----------------------------------------------- */
    
    /* An SSL structure is created */
    //meth = SSLv23_client_method();
    meth = TLSv1_method();
    ctx = SSL_CTX_new(meth);                        
    ssl = SSL_new (ctx);
    sbio=BIO_new_socket(sock,BIO_NOCLOSE);
    SSL_set_bio(ssl,sbio,sbio);
    
    /* Assign the socket into the SSL structure (SSL and socket without BIO) */
    //SSL_set_fd(ssl, sock);
    /* Perform SSL Handshake on the SSL client */
    err = SSL_connect(ssl);
    /* Informational output (optional) */
    printf ("SSL connection using %s\n", SSL_get_cipher (ssl));
    return 1;
    
}


char* epplogin(void)
{
    char *xmllogin = malloc(512);
    snprintf(xmllogin,512,"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"
             "<epp xmlns=\"urn:ietf:params:xml:ns:epp-1.0\">"
             "<command><login><clID>%s</clID><pw>%s</pw><options><version>1.0</version><lang>en</lang></options><svcs>"
             "<objURI>urn:ietf:params:xml:ns:contact-1.0</objURI><objURI>urn:ietf:params:xml:ns:host-1.0</objURI>"
             "<objURI>urn:ietf:params:xml:ns:domain-1.0</objURI>"
             "<svcExtension><extURI>urn:ietf:params:xml:ns:sidn-ext-epp-1.0</extURI></svcExtension>"
             "</svcs></login></command></epp>",eppuser,epppass);
    return xmllogin;
}

char* epplogout(void)
{
    char *xmllogout = malloc(512);
    snprintf(xmllogout,512,
             "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
             "<epp xmlns=\"urn:ietf:params:xml:ns:epp-1.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd\">"
             "<command><logout/></command></epp>");
    return xmllogout;
}


char* epphello(void)
{
    char *xmlhello = malloc(128);
    snprintf(xmlhello,128,"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>"
             "<epp xmlns=\"urn:ietf:params:xml:ns:epp-1.0\">"
             "<hello/></epp>");
    return xmlhello;
}

int main()
{
    // Connect to SSL socket
    sslconnect();
    sslrecv(); // Read greeting
    sslsend(epplogin()); //Login
    sslrecv();    // Response
    sslsend(epphello()); // Hello
    sslrecv();    // Response
    sslsend(epplogout()); 
    sslrecv();    // Response
    sslclose(); // Kill SSL en SOCK
    return 1;
};

[RobIII]

Je weet beter. Je legt je probleem erg summier uit en dumpt vervolgens ~200 regels code die wij dan mogen gaan uitpluizen en debuggen. Zo werkt het hier niet.

Quickstart
Kan iemand even...?

Wat heb je zelf geprobeerd? Heb je al gedebugged (Debuggen: Hoe doe ik dat?)? Al gezocht? Iets gevonden? Wat werkte daar niet aan? Etc. etc. etc. Ik mis elke vorm van eigen inzet en je weet dat we dat hier vragen.

Overigens; voor jou is het misschien wel duidelijk maar je beseft dat een heleboel mensen misschien nog nooit van "EPP" hebben gehoord? Het is nou niet bepaald een gangbaar iets AFAIK. Het zou handig zijn als je op z'n minst even wat daarover had verteld of een linkje erbij had gezet of...

Tot slot: Je hoeft niet telkens om de
zoveel woorden op enter te meppen,
dat leest nogal vervelend. Het forum
kan prima zelf tekstomloop regelen.

[ Voor 236% gewijzigd door RobIII op 30-07-2011 14:33 ]