linux下socket编程

❶ socket编程在windows和linux下的区别是什么

1.
头文件
windows下winsock.h或winsock2.h
linux下netinet/in.h（大部分都在这儿），unistd.h（close函数在这儿），sys/socket.h（在in.h里已经包含了，可以省了）
2.
初始化
windows下需要用WSAStartup启动Ws2_32.lib，并且要用#pragma
comment(lib,"Ws2_32")来告知编译器链接该lib。
linux下不需要
3.
关闭socket
windows下closesocket(...)
linux下close(...)
4.
类型
windows下SOCKET
linux下int
5.
获取错误码
windows下getlasterror()/WSAGetLastError()
linux下，未能成功执行的socket操作会返回-1；如果包含了errno.h，就会设置errno变量
6.
设置非阻塞
windows下ioctlsocket()
linux下fcntl()，需要头文件fcntl.h
7.
send函数最后一个参数
windows下一般设置为0
linux下最好设置为MSG_NOSIGNAL，如果不设置，在发送出错后有可能会导致程序退出
8.
毫秒级时间获取
windows下GetTickCount()
linux下gettimeofday()

❷ linux下的socket编程在哪进行

LINUX下的SOCKET编程？应该所有语言都有相应的SOCKET编程接口。
C/C++、JAVA，python，RUBY，PERL，甚至是SCEME。
只不过，其他几种都是跨平台的，不算是单独的LINUX下SOCKET编程。一般C语言和C++才这么说。因为LINUX下的接口和WINDOWS不一样。
想知道接口有哪些的话，你得查手册或是看《UNIX环境高级编程》这类书，书上会有LINUX/UNIX的C编程接口。
编译环境的话，只要是C语言编译器，LINUX支持的主要是GCC，LINUX下的开发环境IDE也默认都用GCC了，比如CODEBLOCKS、GEANY什么的。按下编译、运行按钮就行了，和WINDOWS下开发的步骤差不多，只是接口不一样。
如果要用命令行的话，也不难，代码写好了，gcc 一下就可以编译了。不过，看你的水平，算了吧……要么安心学一下LINUX下编程，要么老实地用IDE。

问这种问题，让人很难回答的……在哪进行，当然在LINUX下，在LINUX的C语言代码文件里，什么编译环境？C语言的编译环境……什么编译工具，C语言的编译工具，比如GCC。

❸ linux下socket编程：关于文件传输的问题

接收文件客户端的这块代码是不是写错了？
if(buflen > 0)break;

假定你是往上写的时候的手误，那么
你的程序是否客户端/服务器端都是运行在linux，尤其是发送文件的客户端与接收文件的客户端是否都运行在linux上？

如果运行在windows上，在打开文件的时候（fopen)， 必须用二进制方式打开，如
foepn("path/to/file", "rb")

否则windows下默认用文本方式打开，会把文件中的"\r\n"转换成一个字符 "\r"，从而导致你看到文件大小变小的现象。

PS: 建议所有的文件传送程序，在读写文件的时候都用二进制方式打开。

❹ socket编程在windows和linux下的区别

下面大概分几个方面进行罗列：

Linux要包含

[cpp]
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
等头文件，而windows下则是包含
[cpp]
#include <winsock.h>
。

Linux中socket为整形，Windows中为一个SOCKET。
Linux中关闭socket为close，Windows中为closesocket。
Linux中有变量socklen_t，Windows中直接为int。
因为linux中的socket与普通的fd一样，所以可以在TCP的socket中，发送与接收数据时，直接使用read和write。而windows只能使用recv和send。
设置socet选项，比如设置socket为非阻塞的。Linux下为

[cpp]
flag = fcntl (fd, F_GETFL);
fcntl (fd, F_SETFL, flag | O_NONBLOCK);
，Windows下为
[cpp]
flag = 1;
ioctlsocket (fd, FIONBIO, (unsigned long *) &flag);
。
当非阻塞socket的TCP连接正在进行时，Linux的错误号为EINPROGRESS，Windows的错误号为WSAEWOULDBLOCK。

file
Linux下面，文件换行是"\n"，而windows下面是"\r\n"。
Linux下面，目录分隔符是"/"，而windows下面是"\"。
Linux与Windows下面，均可以使用stat调用来查询文件信息。但是，Linux只支持2G大小，而Windows只支持4G大小。为了支持更大的文件查询，可以在Linux环境下加

_FILE_OFFSET_BITS=64定义，在Windows下面使用_stat64调用，入参为struct __stat64。
Linux中可根据stat的st_mode判断文件类型，有S_ISREG、S_ISDIR等宏。Windows中没有，需要自己定义相应的宏，如

[cpp]
#define S_ISREG(m) (((m) & 0170000) == (0100000))
#define S_ISDIR(m) (((m) & 0170000) == (0040000))
Linux中删除文件是unlink，Windows中为DeleteFile。

time

Linux中，time_t结构是长整形。而windows中，time_t结构是64位的整形。如果要在windows始time_t为32位无符号整形，可以加宏定义，_USE_32BIT_TIME_T。
Linux中，sleep的单位为秒。Windows中，Sleep的单位为毫秒。即，Linux下sleep (1)，在Windows环境下则需要Sleep (1000)。
Windows中的timecmp宏，不支持大于等于或者小于等于。
Windows中没有struct timeval结构的加减宏可以使用，需要手动定义：

[cpp]
#define MICROSECONDS (1000 * 1000)

#define timeradd(t1, t2, t3) do { \
(t3)->tv_sec = (t1)->tv_sec + (t2)->tv_sec; \
(t3)->tv_usec = (t1)->tv_usec + (t2)->tv_usec % MICROSECONDS; \
if ((t1)->tv_usec + (t2)->tv_usec > MICROSECONDS) (t3)->tv_sec ++; \
} while (0)

#define timersub(t1, t2, t3) do { \
(t3)->tv_sec = (t1)->tv_sec - (t2)->tv_sec; \
(t3)->tv_usec = (t1)->tv_usec - (t2)->tv_usec; \
if ((t1)->tv_usec - (t2)->tv_usec < 0) (t3)->tv_usec --, (t3)->tv_usec += MICROSECONDS; \
} while (0)

调用进程

Linux下可以直接使用system来调用外部程序。Windows最好使用WinExec，因为WinExec可以支持是打开还是隐藏程序窗口。用WinExec的第二个入参指明，如

SW_SHOW/SW_HIDE。

杂项

Linux为srandom和random函数，Windows为srand和rand函数。
Linux为snprintf，Windows为_snprintf。
同理，Linux中的strcasecmp，Windows为_stricmp。

错误处理

Linux下面，通常使用全局变量errno来表示函数执行的错误号。Windows下要使用GetLastError ()调用来取得。

Linux环境下仅有的
这些函数或者宏，Windows中完全没有，需要用户手动实现。
atoll

[cpp]
long long
atoll (const char *p)
{
int minus = 0;
long long value = 0;
if (*p == '-')
{
minus ++;
p ++;
}
while (*p >= '0' && *p <= '9')
{
value *= 10;
value += *p - '0';
p ++;
}
return minus ? 0 - value : value;
}
gettimeofday

[cpp]
#if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
#define EPOCHFILETIME 11644473600000000Ui64
#else
#define EPOCHFILETIME 11644473600000000ULL
#endif

struct timezone
{
int tz_minuteswest;
int tz_dsttime;
};

int
gettimeofday (struct timeval *tv, struct timezone *tz)
{
FILETIME ft;
LARGE_INTEGER li;
__int64 t;
static int tzflag;

if (tv)
{
GetSystemTimeAsFileTime (&ft);
li.LowPart = ft.dwLowDateTime;
li.HighPart = ft.dwHighDateTime;
t = li.QuadPart; /* In 100-nanosecond intervals */
t -= EPOCHFILETIME; /* Offset to the Epoch time */
t /= 10; /* In microseconds */
tv->tv_sec = (long) (t / 1000000);
tv->tv_usec = (long) (t % 1000000);
}

if (tz)
{
if (!tzflag)
{
_tzset ();
tzflag++;
}
tz->tz_minuteswest = _timezone / 60;
tz->tz_dsttime = _daylight;
}

return 0;
}

编译相关
当前函数，Linux用__FUNCTION__表示，Windows用__func__表示。
--------------------------------------------------------------------------------
Socket 编程 windows到Linux代码移植遇到的问题
1)头文件
windows下winsock.h/winsock2.h
linux下sys/socket.h
错误处理：errno.h

2)初始化
windows下需要用WSAStartup
linux下不需要

3)关闭socket
windows下closesocket(...)
linux下close(...)

4)类型
windows下SOCKET
linux下int
如我用到的一些宏：
#ifdef WIN32
typedef int socklen_t;
typedef int ssize_t;
#endif

#ifdef __LINUX__
typedef int SOCKET;
typedef unsigned char BYTE;
typedef unsigned long DWORD;
#define FALSE 0
#define SOCKET_ERROR (-1)
#endif

5)获取错误码
windows下getlasterror()/WSAGetLastError()
linux下errno变量

6)设置非阻塞
windows下ioctlsocket()
linux下fcntl() <fcntl.h>

7)send函数最后一个参数
windows下一般设置为0
linux下最好设置为MSG_NOSIGNAL，如果不设置，在发送出错后有可 能会导致程序退出。

8)毫秒级时间获取
windows下GetTickCount()
linux下gettimeofday()

3、多线程
多线程: (win)process.h --〉(linux)pthread.h
_beginthread --> pthread_create
_endthread --> pthread_exit
-----------------------------------------------------------------
windows与linux平台使用的socket均继承自Berkeley socket(rfc3493)，他们都支持select I/O模型，均支持使用getaddrinfo与getnameinfo实现协议无关编程。但存在细微差别，

主要有：

头文件及类库。windows使用winsock2.h(需要在windows.h前包含)，并要链接库ws2_32.lib；linux使用netinet/in.h, netdb.h等。
windows下在使用socket之前与之后要分别使用WSAStartup与WSAClean。
关闭socket，windows使用closesocket，linux使用close。
send*与recv*函数参数之socket长度的类型，windows为int，linux为socklen_t，可预编译指令中处理这一差异，当平台为windows时#define socklen_t unsigned int。
select函数第一个参数，windows忽略该参数，linux下该参数表示集合中socket的上限值，一般设为sockfd(需select的socket) + 1。
windows下socket函数返回值类型为SOCKET(unsigned int)，其中发生错误时返回INVALID_SOCKET(0)，linux下socket函数返回值类型int, 发生错误时返回-1。
另外，如果绑定本机回环地址，windows下sendto函数可以通过，linux下sendto回报错：errno=22, Invalid arguement。一般情况下均绑定通配地址。
转载jlins

❺ socket编程在windows和linux下的区别

socket在原理上应该是一样的，只是不同系统的运行机置有些不同。
socket
编程
windows到linux代码移植遇到的问题
1、一些常用函数的移植
2、网络
socket相关程序从windows移植到linux下需要注意的
1)头文件
windows下winsock.h/winsock2.h
linux下sys/socket.h
错误处理：errno.h
其他常用函数的头文件可到命令行下用man指令查询。
2)初始化
windows下需要用wsastartup
linux下不需要（很方便），直接可以使用
3)关闭socket
windows下closesocket(...)
linux下close(...)
4)类型
windows下socket
在linux下为int类型
5)绑定地址的结构体
名称相同，都是struct
sockaddr、struct
sockaddr_in，这两者通常转换使用；

❻ linux下socket编程，菜鸟求解。。。

linux-u4p5:~/test/socket/server # ./client
connect ok,waiting for the server's message back
程序好像没看出问题来啊
会不会是防火墙设置问题？

❼ linux下socket编程，怎样把文件和文件属性一起发送到服务器端

socket可以发送任意类型的数据。socket本身不限制你要发送什么，而是由你自己来定要发什么的。只要你接收端能识别发来的是什么即可。
协议的三个基本要素，语法、语义、同步。比如你用于表示文件属性的结构体或者其他什么数据长度固定是20字节，那么你就在发送文件内容之前把这20字节发送过去，接收端在接收内容之前，固定会先接收20字节并作为文件属性，随后接收到的内容才作为数据存入文件，这样就可以做到了。
关键点就在于自己要定好语法、语义、同步这些，发送端和接收端配合好动作。

❽ linux下socket编程，请大神详解 serv_addr.sin_addr = *((struct in_addr *)host->h_addr);

-> 是结构体指针变量引用结构体成员变量的方法。

一般结构体引用成员变量用.(点)。
struct stu {
char name[10];
int age ;
} s, *p=s ;

strcpy( s.name , "Jack" );
s.age=20 ;
也可以用指针来操作
strcpy( p->name , "Jack" );
p->age=20 ;
当指向s时，与上面两句等价。

❾ linux下C语言socket编程双机互发数据

这个问题很好办啦，服务器接受一个连接请求，然后开一个线程或者进程都可以，再在线程或者进程里面采用其他技术实现同时收发(比如I/O复用，比如非阻塞I/O)。客户端也可以采用I/O复用。

推荐资料的话，《unix网络编程》这本书很好，公认的经典，当教科书用，这本书里有你想要的所有内容。

ps:你基础太差，多补补吧，别想一下吃个胖子。

另外我这里正好有个例子满足你的要求,贴给你，自己写的，不是网上找的,用的是多进程加I/O复用技术:

server端:
/****************************************************************
**
**
**
****************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>

#define BUFLEN 1024
#define MAX(a,b) ((a)>(b)?(a):(b))

typedef void Sigfunc (int);

void str_echo(FILE *,int);
//Sigfunc *signal(int, Sigfunc *);

int main(int argc,char **argv)
{
int connfd,listenfd;
pid_t childpid;
socklen_t clilen;
struct sockaddr_in cliaddr,servaddr;
void sig_chld(int);

listenfd = socket(AF_INET, SOCK_STREAM, 0);

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

bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
listen(listenfd,8);

signal(SIGCHLD,sig_chld);

while(1)
{
clilen = sizeof(cliaddr);
if((connfd = accept(listenfd,(struct sockaddr*)&cliaddr,&clilen)) < 0)
{
if(errno == EINTR)
{
fputs("accept error: EINTR\n",stdout);
continue;
}
else
{
fputs("accept error..\n",stdout);
}
}

if((childpid = fork()) == 0)
{
close(listenfd);
str_echo(stdin,connfd);
exit(0);
}
close(connfd);
}
}

void str_echo(FILE *fp,int sockfd)
{
int n = 0;
char sendbuf[BUFLEN] = { 0 },recvbuf[BUFLEN] = { 0 };
int maxfdp;
fd_set rset;

FD_ZERO(&rset);

while(1)
{
FD_SET(fileno(fp),&rset);
FD_SET(sockfd, &rset);
maxfdp = MAX(fileno(fp),sockfd)+1;

select(maxfdp, &rset ,NULL, NULL, NULL);

if(FD_ISSET(sockfd, &rset))
{
if(n = read(sockfd, recvbuf, BUFLEN) == 0)
{
return;
}
if(n == -1)
{
break;
}
printf("%s\n",recvbuf);
memset(recvbuf,0,BUFLEN);
}
if(FD_ISSET(fileno(fp),&rset))
{
scanf("%s",sendbuf);
write(sockfd, sendbuf,strlen(sendbuf));
}
}
}

void sig_chld (int signo)
{
pid_t pid;
int stat;

while ((pid = waitpid(-1,&stat, WNOHANG)) > 0)
{
printf("child %d terminated\n",pid);
}
return;
}

client端:
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>

#define MAX(a,b) (a)>(b)?(a):(b)

int main()
{
int s,connectReturn, maxfd;
fd_set rset;
char sendbuf[1024] = {0};
char recvbuf[1024] = {0};
long port=5358;
s=socket(PF_INET,SOCK_STREAM,0);

struct sockaddr_in sa;
sa.sin_family=AF_INET;
sa.sin_addr.s_addr=inet_addr("127.0.0.1");
sa.sin_port=htons(port);
connectReturn=connect(s,(struct sockaddr *)&sa,sizeof(sa));
printf("%d\n",connectReturn);
FD_ZERO(&rset);
while(1)
{
FD_SET(fileno(stdin), &rset);
FD_SET(s, &rset);
maxfd=MAX(fileno(stdin), s) + 1;

select(maxfd, &rset, NULL, NULL, NULL);
if(FD_ISSET(fileno(stdin), &rset))
{
scanf("%s",sendbuf);
send(s,sendbuf,strlen(sendbuf),0);
bzero(sendbuf, 1024);
}
else if(FD_ISSET(s, &rset))
{
memset(recvbuf,0,1024);
recv(s,recvbuf,1024,0);
printf("remote: %s\n",recvbuf);
}
}
return 0;
}

❿ linux下socket编程中connect（）函数

关闭后，要再次调用
socket(AF_INET,SOCK_STREAM,0);
来创建socket, 才可以

补充：Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。它能运行主要的UNIX工具软件、应用程序和网络协议。它支持32位和64位硬件。Linux继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。

。