Sockets 无法修复错误10038 WSAENOTSOCK_Sockets

Sockets 无法修复错误10038 WSAENOTSOCK

sockets

Sockets 无法修复错误10038 WSAENOTSOCK,sockets,Sockets,我试图学习Berkeley Socket编程，但我真的被困在这里：我的服务器和客户端程序都出现了10038错误，根据MSDN的说法，这意味着：“试图对不是套接字的东西进行操作”，但我的套接字是“套接字”。以下是服务器/客户端代码：我的客户： #include <winsock.h> #include <stdio.h> #include <string.h> #define BUFFSIZE 32 void DieWithError(char *err

我试图学习Berkeley Socket编程，但我真的被困在这里：我的服务器和客户端程序都出现了10038错误，根据MSDN的说法，这意味着：“试图对不是套接字的东西进行操作”，但我的套接字是“套接字”。以下是服务器/客户端代码：

我的客户：

#include <winsock.h>
#include <stdio.h>
#include <string.h>

#define BUFFSIZE 32

void DieWithError(char *errorMessage);

int main(int argc, char* argv[]){

    int sock, bytesLen;
    struct sockaddr_in servAddr;
    unsigned short servPort =13;
    char * servIP;
    char buff[BUFFSIZE+1];
    WSADATA wsaData;

    if(argc == 2){
        servIP = argv[1];
    }

    if(WSAStartup(MAKEWORD(2,0), &wsaData) != 0){
        puts("ERROR WSA");
    }

    if(sock=socket(AF_INET, SOCK_STREAM, 0) < 0){
        puts("ERROR socket");
    }

    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family   = AF_INET;
    servAddr.sin_port     = htons(servPort);
    servAddr.sin_addr.s_addr = inet_addr(&servIP);

    if(connect(sock, (struct sockaddr *)&servAddr, sizeof(servAddr)<0)){
        DieWithError("connect Error");
    }

    while(bytesLen=read(sock, buff, BUFFSIZE)){
        buff[bytesLen]= '\n';
    }

    printf("Heure : %s",buff);

    closesocket(sock);
    WSACleanup();

    return 0;
}

void DieWithError(char *errorMessage)
{
    fprintf(stderr,"%s: %d\n",
    errorMessage, WSAGetLastError());
    exit(1);
}

#包括
#包括
#包括
#定义大小32
无效DIEWERROR（字符*错误消息）；
int main（int argc，char*argv[]）{
int sock，bytesLen；
servAddr中的结构sockaddr_；
无符号短服务端口=13；
char*servIP；
字符buff[BUFFSIZE+1]；
WSADATA WSADATA；
如果（argc==2）{
servIP=argv[1]；
}
if（WSAStartup（MAKEWORD（2,0），&wsaData）！=0）{
看跌期权（“错误WSA”）；
}
if（sock=socket（AF\u INET，sock\u STREAM，0）<0）{
puts（“错误套接字”）；
}
memset（&servAddr，0，sizeof（servAddr））；
servAddr.sin_family=AF_INET；
servAddr.sin_port=htons（servPort）；
servAddr.sin\u addr.s\u addr=inet\u addr（&servIP）；
if（connect（sock，（struct sockaddr*）&servAddr，sizeof（servAddr）与其他平台不同，Windows不使用文件描述符来表示套接字。它使用实际的内核对象。其他平台使用int
来表示打开的文件描述符，从而表示套接字。Windows使用SOCKET
类型，它是UINT\u PTR
（unsigned int
为32位，unsigned\u int64
为64位），因此它可以容纳对象句柄。Windows上的socket（）
函数在出错时返回无效的\u socket
（即（socket）（~0）
），而其他平台返回（int）-1
相反。您需要确保对此进行了说明，以免在Windows上分割/截断合法的套接字句柄
当您的客户端调用inet\u addr（）
时，它正在传递一个char**
，其中需要一个char*
。您的编译器应该报告一个错误
由于套接字在Windows上不表示为文件描述符，因此不能将read（）
和write（）
函数用于Windows套接字。必须使用recv（）
/WSARecv（）
和send（）
/WSASend（）
函数。您需要处理函数在出错时返回套接字错误的情况
请尝试类似以下内容：
客户：
#include <winsock.h>
#include <stdio.h>
#include <string.h>

#define BUFFSIZE 32

void DieWithErrorCode(char *errorMessage, int errCode);
void DieWithError(char *errorMessage, int *errCode = NULL);

int main(int argc, char* argv[])
{
    SOCKET sock;
    int ret;
    struct sockaddr_in servAddr;
    unsigned short servPort = 13;
    char *servIP;
    char buff[BUFFSIZE];
    WSADATA wsaData;

    if (argc != 2) {
        DieWithErrorCode("ERROR argc", WSAEINVAL);
    }
    servIP = argv[1];

    ret = WSAStartup(MAKEWORD(2,0), &wsaData);
    if (ret != 0) {
        DieWithErrorCode("ERROR WSAStartup", ret);
    }

    sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sock == INVALID_SOCKET) {
        DieWithError("ERROR socket");
    }

    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = AF_INET;
    servAddr.sin_port = htons(servPort);
    servAddr.sin_addr.s_addr = inet_addr(servIP);
    if (servAddr.sin_addr.s_addr == INET_NONE) {
        DieWithErrorCode("ERROR inet_addr", WSAEINVAL);
    }

    if (connect(sock, (struct sockaddr *)&servAddr, sizeof(servAddr)) == SOCKET_ERROR) {
        DieWithError("ERROR connect");
    }

    while(1) {
        ret = recv(sock, buff, BUFFSIZE, 0);
        if (ret == SOCKET_ERROR) {
            DieWithError("ERROR recv");
        }

        if (ret == 0) {
            fprintf(stderr, "disconnected\n");
            break;
        }

        printf("Heure : %.*s\n", ret, buff);
    }

    closesocket(sock);
    WSACleanup();

    return 0;
}

void DieWithErrorCode(char *errorMessage, int errCode)
{
    fprintf(stderr, "%s: %d\n", errorMessage, errCode);
    exit(1);
}

void DieWithError(char *errorMessage)
{
    DieWithErrorCode(errorMessage, WSAGetLastError());
}

#包括
#包括
#包括
#定义大小32
无效错误代码（字符*错误消息，整数错误代码）；
无效错误（字符*errorMessage，int*errCode=NULL）；
int main（int argc，char*argv[]）
{
插座；
int ret；
servAddr中的结构sockaddr_；
无符号短服务端口=13；
char*servIP；
字符buff[BUFFSIZE]；
WSADATA WSADATA；
如果（argc！=2）{
错误代码（“错误argc”，WSAEINVAL）；
}
servIP=argv[1]；
ret=WSAStartup（MAKEWORD（2,0）和wsaData）；
如果（ret！=0）{
错误代码（“错误WSAStartup”，ret）；
}
sock=套接字（AF_INET、sock流、IPPROTO_TCP）；
if（sock==无效的_套接字）{
DIEWERROR（“错误套接字”）；
}
memset（&servAddr，0，sizeof（servAddr））；
servAddr.sin_family=AF_INET；
servAddr.sin_port=htons（servPort）；
servAddr.sin\u addr.s\u addr=inet\u addr（servIP）；
if（servAddr.sin\u addr.s\u addr==INET\u NONE）{
DIEWERRORCODE（“错误inet_addr”，WSAEINVAL）；
}
if（connect（sock，（struct sockaddr*）&servAddr，sizeof（servAddr））==SOCKET\u错误）{
DIEWERROR（“错误连接”）；
}
而(1){
ret=recv（袜子，浅黄色，浅黄色尺寸，0）；
if（ret==套接字错误）{
DIEWERROR（“错误记录”）；
}
如果（ret==0）{
fprintf（stderr，“断开\n”）；
打破
}
printf（“Heure:%.*s\n”，ret，buff）；
}
插座；
WSACleanup（）；
返回0；
}
无效错误代码（字符*错误消息，整数错误代码）
{
fprintf（标准，“%s:%d\n”、错误消息、错误代码）；
出口（1）；
}
无效错误（字符*错误消息）
{
DIEWERRORCODE（错误消息，WSAGetLastError（））；
}

服务器：
#include <winsock.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>

#define MAXLINE 32

void DieWithErrorCode(char *errorMessage, int errCode);
void DieWithError(char *errorMessage);

int main()
{
    SOCKET sock, sockc;
    struct sockaddr_in servAddr;
    unsigned short servPort = 13;
    time_t ticks;
    WSADATA wsaData;
    char buff[MAXLINE];
    int ret, buflen;

    ret = WSAStartup(MAKEWORD(2,0), &wsaData);
    if (ret != 0) {
        DieWithErrorCode("ERROR WSA", ret);
    }

    sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sock == INVALID_SOCKET) {
        DieWithError("ERROR socket");
    }

    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = AF_INET;
    servAddr.sin_port = htons(servPort);
    servAddr.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(sock, (struct sockaddr *)&servAddr, sizeof(servAddr)) == SOCKET_ERROR) {
        DieWithError("ERROR bind");
    }

    if (listen(sock, MAXQUEUE) == SOCKET_ERROR) {
        DieWithError("ERROR listen");
    }

    while(1) {
        sockc = accept(sock, NULL, NULL);
        if (sockc == INVALID_SOCKET) {
            DieWithError("ERROR accept");
        }

        ticks = time(NULL);
        buflen = snprintf(buff, sizeof(buff), "%s", ctime(&ticks));
        if (send(sockc, buff, buflen, 0) == SOCKET_ERROR) {
            fprintf(stderr, "ERROR send: %d\n", WSAGetLastError());
        }

        closesocket(sockc);
    }

    closesocket(sock);
    WSACleanup();

    return 0;
}

void DieWithErrorCode(char *errorMessage, int errCode)
{
    fprintf(stderr,"%s: %d\n", errorMessage, errCode);
    exit(1);
}

void DieWithError(char *errorMessage)
{
    DieWithErrorCode(char *errorMessage, WSAGetLastError());
}

#包括
#包括
#包括
#包括
#包括
#定义MAXLINE 32
无效错误代码（字符*错误消息，整数错误代码）；
无效DIEWERROR（字符*错误消息）；
int main（）
{
插座插座，插座C；
servAddr中的结构sockaddr_；
无符号短服务端口=13；
时间滴答；
WSADATA WSADATA；
字符buff[MAXLINE]；
布弗伦国际网；
ret=WSAStartup（MAKEWORD（2,0）和wsaData）；
如果（ret！=0）{
错误代码（“错误WSA”，ret）；
}
sock=套接字（AF_INET、sock流、IPPROTO_TCP）；
if（sock==无效的_套接字）{
DIEWERROR（“错误套接字”）；
}
memset（&servAddr，0，sizeof（servAddr））；
servAddr.sin_family=AF_INET；
servAddr.sin_port=htons（servPort）；
servAddr.sin\u addr.s\u addr=htonl（INADDR\u ANY）；
if（bind（sock，（struct sockaddr*）&servAddr，sizeof（servAddr））==SOCKET\u错误）{
DIEWERROR（“错误绑定”）；
}
if（侦听（sock，MAXQUEUE）==SOCKET\u错误）{
迪威瑟罗（“错误监听”）；
}
而(1){
sockc=accept（sock，NULL，NULL）；
if（sockc==无效的_套接字）{
DIEWERROR（“错误接受”）；
}
刻度=时间（空）；
buflen=snprintf（buff，sizeof（buff），“%s”，ctime（&ticks））；
如果（发送（sockc，buff，bufflen，0）=套接字错误）{
fprintf（stderr，“错误发送：%d\n”，WSAGetLastError（））；
}
闭合插座（sockc）；
}
插座；
WSACleanup（）；
返回0；
}
无效错误代码（字符*错误消息，整数错误代码）
{
fprintf（标准，“%s:%d\n”、错误消息、错误代码）；
出口（1）；
}
无效错误（字符*错误消息）
{
DIEWERRORCODE（char*errorMessage，WSAGetLastError（））；
}
谢谢您的帮助，非常有用。
#include <winsock.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>

#define MAXLINE 32

void DieWithErrorCode(char *errorMessage, int errCode);
void DieWithError(char *errorMessage);

int main()
{
    SOCKET sock, sockc;
    struct sockaddr_in servAddr;
    unsigned short servPort = 13;
    time_t ticks;
    WSADATA wsaData;
    char buff[MAXLINE];
    int ret, buflen;

    ret = WSAStartup(MAKEWORD(2,0), &wsaData);
    if (ret != 0) {
        DieWithErrorCode("ERROR WSA", ret);
    }

    sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sock == INVALID_SOCKET) {
        DieWithError("ERROR socket");
    }

    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = AF_INET;
    servAddr.sin_port = htons(servPort);
    servAddr.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(sock, (struct sockaddr *)&servAddr, sizeof(servAddr)) == SOCKET_ERROR) {
        DieWithError("ERROR bind");
    }

    if (listen(sock, MAXQUEUE) == SOCKET_ERROR) {
        DieWithError("ERROR listen");
    }

    while(1) {
        sockc = accept(sock, NULL, NULL);
        if (sockc == INVALID_SOCKET) {
            DieWithError("ERROR accept");
        }

        ticks = time(NULL);
        buflen = snprintf(buff, sizeof(buff), "%s", ctime(&ticks));
        if (send(sockc, buff, buflen, 0) == SOCKET_ERROR) {
            fprintf(stderr, "ERROR send: %d\n", WSAGetLastError());
        }

        closesocket(sockc);
    }

    closesocket(sock);
    WSACleanup();

    return 0;
}

void DieWithErrorCode(char *errorMessage, int errCode)
{
    fprintf(stderr,"%s: %d\n", errorMessage, errCode);
    exit(1);
}

void DieWithError(char *errorMessage)
{
    DieWithErrorCode(char *errorMessage, WSAGetLastError());
}