Comment envoyer des caractères larges en utilisant la fonction send() de winsock?

Question

Il est dit here que la fonction d'envoi attend constchar *.

Comment envoyer des caractères larges? J'ai essayé ce qui suit:

void MyClass::socksend(const wchar_t* wbuffer) { 
    int i; 
    char *buffer = (char *)malloc(MB_CUR_MAX); 
    wctomb_s(&i,buffer, MB_CUR_MAX, (wchar_t)wbuffer); 
    int buflen = strlen(buffer) + 2; 
    char sendbuf[DEFAULT_BUFLEN]; 
    strcpy_s(sendbuf,buflen,buffer); 
    sendbuf[buflen - 1] = '\n'; 
    int senderror = send(this->m_socket, sendbuf, buflen, 0); 
    // error handling, etc goes here... 

} 

Cela ne fait pas ce que je l'espère. Il ne semble pas envoyer quoi que ce soit à la socket. Comment puis-je réparer ça?

Answer 1

Notez que je ne suis pas sûr de la bonne façon de transférer des chaînes de caractères larges à travers une socket, donc pour cette partie, vous êtes seul. Je sais que cela m'a été décrit comme assez poilu et alambiqué. :) Dans cet esprit, si l'autre côté de la douille attend une chaîne de wchar_t, vous pouvez utiliser wcslen pour obtenir la longueur de la chaîne à laquelle les points wbuffer, vous donnant

 
int senderror = send(this->m_socket, (char *)wbuffer, wcslen(wbuffer) * sizeof(wchar_t), 0); 

Il y a aussi quelques bogues possibles dans votre code. Si vous devez convertir la chaîne wchar_t en multi-octets, vous devez utiliser wcstombs_s au lieu de wctomb_s. wctombs_s convertit un caractère à la fois tandis que wcstombs_s convertit une chaîne.

Si la chaîne résultante est plus longue que DEFAULT_BUFLEN, vous finirez par tronquer la chaîne avec '\ n' et en laissant tomber toute donnée au-delà de DEFAULT_BUFLEN.

send n'envoie pas toujours le tampon entier. Vous devez boucler l'appel pour envoyer jusqu'à ce que tous les octets sont envoyés ou vous atteignez une certaine limite dans le temps ou des tentatives ou votre patience. Pour plus de détails, voir here.

Answer 2

Qu'est-ce qu'un caractère large en premier lieu? C'est une valeur intégrale plus large que 8 bits; Cela signifie que vous devrez gérer Endianness. Vous devez encoder votre tableau de caractères larges dans un tableau char, puis l'envoyer en tant que tableau char. Du côté de la réception, vous devez décoder le tableau char en tableau de caractères larges.

La fonction wctomb_s ne code pour un seul caractère large -tableau de caractères. La fonction que vous cherchez à encoder un tableau de caractères larges à char array est wcstombs_s. Corrélativement, pour décoder, utilisez mbstowcs_s.

avec la gestion d'erreur omises (non testé):

void MyClass::socksend(const wchar_t* wbuffer) { 
    // determine the required buffer size 
    size_t buffer_size; 
    wcstombs_s(&buffer_size, NULL, 0, wbuffer, _TRUNCATE); 

    // do the actual conversion 
    char *buffer = (char*) malloc(buffer_size); 
    wcstombs_s(&buffer_size, buffer, buffer_size, wbuffer, _TRUNCATE); 

    // send the data 
    size_t buffer_sent = 0; 
    while (buffer_sent < buffer_size) { 
     int sent_size = send(this->m_socket, buffer+buffer_sent, buffer_size-buffer_sent, 0); 
     buffer_sent += sent_size; 
    } 

    // cleanup 
    free(buffer); 
}