基于socket的聊天程序c语言,c语言socket函数
用c语言写个 socket tcp 的
#include winsock2.h
#include stdio.h
#include pthread.h
#pragma comment(lib,"ws2_32.lib")
typedef struct{
SOCKET accpt;
int lock;
}Arg;
void *transfer(void *arg)
{
Arg * info = (Arg *)arg;
SOCKET clientSock;
char recvbuf[102];
char sendBuf[] = "10";
int ret;
memcpy(clientSock,(void*)info-accpt,sizeof(clientSock));
info-lock =1;
while (TRUE)
{
ret = send(clientSock,sendBuf,2,0);
if (ret == -1)
{
break;
}
ret = recv(clientSock,recvbuf,102,0);
printf("%s\n",recvbuf);
}
return (void *)0;
}
void* timer(void *arg)
{
time_t last = time(NULL);
time_t now;
int i = 20;
while(i--)
{
now = time(NULL);
if(now - last == 1)
{
printf("1s past!\n");
last = now;
}
Sleep(500);
}
printf("timer exit.\n");
return (void *)0;
}
int main(void) {
WSADATA wsaData;
SOCKET ListenSocket;
SOCKADDR_IN service,client;
int len = sizeof(client);
Arg argument;
pthread_t tid;
char sendBuf[] = "ID=2;WHAT=host";
int iResult = WSAStartup(MAKEWORD(2,2), wsaData);
if (iResult != NO_ERROR) {
printf("Error at WSAStartup()\n");
return 1;
}
ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (ListenSocket == INVALID_SOCKET) {
printf("Error at socket(): %ld\n", WSAGetLastError());
WSACleanup();
return 1;
}
service.sin_family = AF_INET;
service.sin_addr.s_addr = inet_addr("127.0.0.1");
service.sin_port = htons(27115);
if (bind( ListenSocket,
(SOCKADDR*) service,
sizeof(service)) == SOCKET_ERROR) {
printf("bind() failed.\n");
closesocket(ListenSocket);
WSACleanup();
return 1;
}
if (listen( ListenSocket, 1 ) == SOCKET_ERROR) {
printf("Error listening on socket.\n");
closesocket(ListenSocket);
WSACleanup();
return 1;
}
argument.lock = 1;
printf("Waiting for client to connect...\n");
pthread_create(tid,NULL,timer,NULL);
while(TRUE){
argument.accpt = accept( ListenSocket, (SOCKADDR*)client, len );
if (argument.accpt == INVALID_SOCKET) {
printf("accept failed: %d\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
} else {
printf("accept%s:%d\n",inet_ntoa(client.sin_addr),client.sin_port);
while (!argument.lock);
argument.lock = 0;
// sendto(argument.accpt,sendBuf,sizeof(sendBuf),0,(SOCKADDR*)client,len);
pthread_create(tid,NULL,transfer,argument);
//send(AcceptSocket,sendBuf,sizeof(sendBuf),0);
}
}
// No longer need server socket
closesocket(ListenSocket);
WSACleanup();
return 0;
}
发送数据格式按需求。可以发送字符串，也可以发送结构体。如果发送结构体的话，要注意序列化和反序列化。程序例子是服务器对每个客户端的connect动作起一个线程去交互。还有一个线程是定时器。
求C语言高手，实现一个简单的TCPIP程序以实现两台计算机之间的聊天通信，
你上面给出的代码其实就是?MSDN?里面的演示代码，不过不完整，只演示了两个函数的使用，我给你看看我写的?TCP?通讯程序，可以在同一个局域网内的两台不同计算机之间聊天?：
这其实就是某本将网络通讯的教程里面的例子，不过是我自己重写了一遍，下面给你代码：
========================
下面是公共代码：
========================
#ifndef?__CINITSOCK__H__
#define?__CINITSOCK__H__
#include?winsock2.h
#include?iphlpapi.h
#pragma?comment(?lib,?"ws2_32.lib"?)
#pragma?comment(?lib,?"iphlpapi.lib"?)
class?CInitSock
{
public:
CInitSock(?int?nMinorVer?=?2,?int?nMajorVer?=?2?)
{
?WSADATA?wsData;
?WORD?wVer?=?MAKEWORD(?nMinorVer,?nMajorVer?);
?if(?0?!=?WSAStartup(?wVer,?wsData?)?)?exit(?0?);
}
~CInitSock(?)
{
?WSACleanup(?);
}
};
#endif
========================
下面是客户端的代码?：
=======================
#include?"CInitSock.h"
#include?iostream
using?namespace?std;
CInitSock?g_Sock;
void?main(?)
{
SOCKET?sockClient?=?socket(?AF_INET,?SOCK_STREAM,?IPPROTO_TCP?);
if(?INVALID_SOCKET?==?sockClient?)
return;
sockaddr_in?sockAddr;
sockAddr.sin_family?=?AF_INET;
sockAddr.sin_port?=?htons(?4567?);
sockAddr.sin_addr.S_un.S_addr?=?inet_addr(?"127.0.0.1"?);
if(?-1?==?connect(?sockClient,?(?sockaddr*?)sockAddr,?sizeof(?sockAddr?)?)?)
{
cout??"connect?failed"??endl;
return;
}
while(?true?)
{
char?szBuf[?MAX_PATH?];
ZeroMemory(?szBuf,?sizeof(?szBuf?)?);
cout??"You?Say?:?";
cin??szBuf;
if(?SOCKET_ERROR? ==?send(?sockClient,?szBuf,?MAX_PATH,?0?)?)
{
?cout??"send?failed"??endl;
?return;
}
int?nRecvLen?=?recv(?sockClient,?szBuf,?MAX_PATH,?0?);
if(?nRecvLen??0?)
{
?//?szBuf[?nRecvLen?]?=?'\0';
?cout??"Service?Say?:?"??szBuf??endl??endl;
}
else
{
?cout??"recv?failed"??endl;
?return;
}
}
closesocket(?sockClient?);
}
======================
下面是服务端的代码：
======================
#include?"CInitSock.h"
#include?iostream
using?namespace?std;
CInitSock?g_Sock;
void?main(?)
{
SOCKET?sockClient?=?socket(?AF_INET,?SOCK_STREAM,?IPPROTO_TCP?);
if(?INVALID_SOCKET?==?sockClient?)
return;
sockaddr_in?sockAddr;
sockAddr.sin_family?=?AF_INET;
sockAddr.sin_port?=?htons(?4567?);
sockAddr.sin_addr.S_un.S_addr?=?INADDR_ANY;
bind(?sockClient,?(?sockaddr*?)sockAddr,?sizeof(?sockAddr?)?);
listen(?sockClient,?SOMAXCONN?);
char?szBuf[?MAX_PATH?];
sockaddr_in?remoteAddr;
int?nLen?=?sizeof(?sockaddr_in?);
SOCKET?sock?=?accept(?sockClient,?(?sockaddr*?)remoteAddr,?nLen?);
while(?true?)
{
int?nRecvLen?=?recv(?sock,?szBuf,?MAX_PATH,?0?);
if(?nRecvLen??0?)
{
?cout??"Client?Say?:?"??szBuf??endl??endl;
}
ZeroMemory(?szBuf,?sizeof(?szBuf?)?);
cout??"You?Say?:?";
cin??szBuf;
if(?SOCKET_ERROR?==?send(?sock,?szBuf,?MAX_PATH,?0?)?)
{
?cout??"send?failed"??endl;
}
}
closesocket(?sock?);
closesocket(?sockClient?);
}
希望能够帮到楼主?。
用Socket编程实现一个基于C/S的应用
例子一：
1 客户端的程序
package net3;
import java.io.*;
import java.net.*;
public class Client {
public static void main(String[] args){
try{
System.out.println("连接到服务器");
Socket s=new Socket("localhost",4005);
BufferedReader b=new BufferedReader(new InputStreamReader(System.in));
BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter pw=new PrintWriter(new OutputStreamWriter(s.getOutputStream()));
String str="";
String sss="";
while(true)
{
str=b.readLine();
pw.println(str);
pw.flush();
//不理睬大小写转换
if(str.equalsIgnoreCase("stop"))
{
System.out.println("服务停止");
break;
}
sss=br.readLine();
System.out.println(sss);
if(sss.equalsIgnoreCase("stop"))
{
System.out.println("服务停止");
break;
}
}
b.close();
br.close();
pw.close();
}
catch(IOException e){}
}
}
2 服务器端的程序：
package net3;
import java.io.*;
import java.net.*;
public class Server {
public static void main(String[] args){
try{
System.out.println("服务器正在启动....");
ServerSocket ss=new ServerSocket(4005);
System.out.println("服务器启动,等待服务...");
Socket s=ss.accept();
BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter bw=new PrintWriter(new OutputStreamWriter(s.getOutputStream()));
String str="";
String sss="";
while(true)
{
sss=br.readLine();
System.out.println(sss);
if(sss.equalsIgnoreCase("stop"))
{
System.out.println("服务停止");
break;
}
str=r.readLine();
bw.println(str);
bw.flush();
//不理睬大小写转换
if(str.equalsIgnoreCase("stop"))
{
System.out.println("服务停止");
break;
}
}
br.close();
r.close();
bw.close();
}
catch(IOException e){}
}
}
例子二：
package test.socket;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
public class TalkMe {
public static void main(String[] args) {
System.out.println("请输入:IP地址：");
TalkMe talk = new TalkMe();
talk.listener().start();
try {
talk.talker(new BufferedReader(new InputStreamReader(System.in)).readLine()).start();
} catch (IOException e) {
e.printStackTrace();
}
}
private Thread listener(){
return new Thread() {
public void run() {
DataInputStream dataIS = null;
String clientSay;
try {
ServerSocket server = new ServerSocket(9666);
Socket socket = server.accept();
while (true) {
dataIS = new DataInputStream(socket.getInputStream());
clientSay = dataIS.readLine();
System.out.println("Other say:" + clientSay);
}
} catch (IOException e) {
e.printStackTrace();
}
}
};
}
private Thread talker(final String ip){
return new Thread(){
public void run() {
Socket socket = null;
InputStreamReader stdin=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(stdin);
DataInputStream dataIS = new DataInputStream(System.in);
OutputStream os;
PrintStream ps;
String say = "";
boolean flag = true;
while (flag) {
if (flag)
System.out.println("connection ....");
try {
socket = new Socket(ip, 9666);
System.out.println("connection ok.");
flag = true;
os = socket.getOutputStream();
ps = new PrintStream(os);
while (true) {
say = dataIS.readLine();
ps.println(say);
}
} catch (UnknownHostException e) {
try {
sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
} catch (IOException e) {
}
}
}
};
}
}
如何利用Socket进行网络编程
Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。请参阅以下资料：socket非常类似于电话插座。以一个国家级电话网为例。电话的通话双方相当于相互通信的 个进程，区号是它的网络地址；区内一个单位的交换机相当于一台主机，主机分配给每个用户的局内号码相当于socket号。任何用户在通话之前，首先要占有一部电话机，相当于申请一个socket；同时要知道对方的号码，相当于对方有一个固定的socket。然后向对方拨号呼叫，相当于发出连接请求(假如对方不在同一区内，还要拨对方区号，相当于给出网络地址)。对方假如在场并空闲(相当于通信的另一主机开机且可以接受连接请求)，拿起电话话筒，双方就可以正式通话，相当于连接成功。双方通话的过程，是一方向电话机发出信号和对方从电话机接收信号的过程，相当于向socket发送数据和从socket接收数据。通话结束后，一方挂起电话机相当于关闭socket，撤消连接。在电话系统中，一般用户只能感受到本地电话机和对方电话号码的存在，建立通话的过程，话音传输的过程以及整个电话系统的技术细节对他都是透明的，这也与socket机制非常相似。socket利用网间网通信设施实现进程通信，但它对通信设施的细节毫不关心，只要通信设施能提供足够的通信能力，它就满足了。至此，我们对socket进行了直观的描述。抽象出来，socket实质上提供了进程通信的端点。进程通信之前，双方首先必须各自创建一个端点，否则是没有法建立联系并相互通信的。正如打电话之前，双方必须各自拥有一台电话机一样。在网间网内部，每一个socket用一个半相关描述:(协议，本地地址，本地端口)一个完整的socket有一个本地唯一的socket号，由操作系统分配。最重要的是，socket是面向客户/服务器模型而设计的，针对客户和服务器程序提供不同的socket系统调用。客户随机申请一个socket(相当于一个想打电话的人可以在任何一台入网电话上拨号呼叫)，系统为之分配一个socket号；服务器拥有全局公认的socket，任何客户都可以向它发出连接请求和信息请求(相当于一个被呼叫的电话拥有一个呼叫方知道的电话号码)。socket利用客户/服务器模式巧妙地解决了进程之间建立通信连接的问题。服务器socket半相关为全局所公认非常重要。读者不妨考虑一下，两个完全随机的用户进程之间如何建立通信？假如通信双方没有任何一方的socket固定，就好比打电话的双方彼此不知道对方的电话号码，要通话是不可能的。实际应用中socket例子Socket接口是访问Internet使用得最广泛的方法。如果你有一台刚配好TCP/IP协议的主机，其IP地址是 . . . ，此时在另一台主机或同一台主机上执行ftp . . . ，显然无法建立连接。因" . . . "这台主机没有运行FTP服务软件。同样，在另一台或同一台主机上运行浏览软件如Netscape，输入"http:// . . . "，也无法建立连接。现在，如果在这台主机上运行一个FTP服务软件（该软件将打开一个Socket，并将其绑定到 端口），再在这台主机上运行一个Web服务软件（该软件将打开另一个Socket，并将其绑定到 端口）。这样，在另一台主机或同一台主机上执行ftp . . . ，FTP客户软件将通过 端口来呼叫主机上由FTP服务软件提供的Socket，与其建立连接并对话。而在netscape中输入"http:// . . . "时，将通过 端口来呼叫主机上由Web服务软件提供的Socket，与其建立连接并对话。在Internet上有很多这样的主机，这些主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。Socket正如其英文原意那样，象一个多孔插座。一台主机犹如布满各种插座的房间，每个插座有一个编号，有的插座提供 伏交流电，有的提供 伏交流电，有的则提供有线电视节目。客户软件将插头插到不同编号的插座，就可以得到不同的服务。一个Server-Client模型程序的开发原理：服务器，使用ServerSocket监听指定的端口，端口可以随意指定（由于 以下的端口通常属于保留端口，在一些操作系统中不可以随意使用，所以建议使用大于 的端口），等待客户连接请求，客户连接后，会话产生；在完成会话后，关闭连接。客户端，使用Socket对网络上某一个服务器的某一个端口发出连接请求，一旦连接成功，打开会话；会话完成后，关闭Socket。客户端不需要指定打开的端口，通常临时的、动态的分配一个 以上的端口。Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程，必须理解Socket接口。Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话，就很容易了解Socket了。网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。常用的Socket类型有两种：流式Socket（SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。Socket建立为了建立Socket，程序可以调用Socket函数，该函数返回一个类似于文件描述符的句柄。socket函数原型为：intsocket(intdomain,inttype,intprotocol);domain指明所使用的协议族，通常为PF_INET，表示互联网协议族（TCP/IP协议族）；type参数指定socket的类型：SOCK_STREAM或SOCK_DGRAM，Socket接口还定义了原始Socket（SOCK_RAW），允许程序使用低层协议；protocol通常赋值" "。Socket()调用返回一个整型socket描述符，你可以在后面的调用使用它。Socket描述符是一个指向内部数据结构的指针，它指向描述符表入口。调用Socket函数时，socket执行体将建立一个Socket，实际上"建立一个Socket"意味着为一个Socket数据结构分配存储空间。Socket执行体为你管理描述符表。两个网络程序之间的一个网络连接包括五种信息：通信协议、本地协议地址、本地主机端口、远端主机地址和远端协议端口。Socket数据结构中包含这五种信息。socket在测量软件中的使用也很广泛socket深层次理解Socket编程基本就是listen，accept以及send，write等几个基本的操作。对于网络编程，我们也言必称TCP/IP，似乎其它网络协议已经不存在了。对于TCP/IP，我们还知道TCP和UDP，前者可以保证数据的正确和可靠性，后者则允许数据丢失。最后，我们还知道，在建立连接前，必须知道对方的IP地址和端口号。除此，普通的程序员就不会知道太多了，很多时候这些知识已经够用了。最多，写服务程序的时候，会使用多线程来处理并发访问。我们还知道如下几个事实： 。一个指定的端口号不能被多个程序共用。比如，如果IIS占用了 端口，那么Apache就不能也用 端口了。 。很多防火墙只允许特定目标端口的数据包通过。 。服务程序在listen某个端口并accept某个连接请求后，会生成一个新的socket来对该请求进行处理。于是，一个困惑了我很久的问题就产生了。如果一个socket创建后并与 端口绑定后，是否就意味着该socket占用了 端口呢？如果是这样的，那么当其accept一个请求后，生成的新的socket到底使用的是什么端口呢（我一直以为系统会默认给其分配一个空闲的端口号）？如果是一个空闲的端口，那一定不是 端口了，于是以后的TCP数据包的目标端口就不是 了--防火墙一定会组织其通过的！实际上，我们可以看到，防火墙并没有阻止这样的连接，而且这是最常见的连接请求和处理方式。我的不解就是，为什么防火墙没有阻止这样的连接？它是如何判定那条连接是因为connet 端口而生成的？是不是TCP数据包里有什么特别的标志？或者防火墙记住了什么东西？后来，我又仔细研读了TCP/IP的协议栈的原理，对很多概念有了更深刻的认识。比如，在TCP和UDP同属于传输层，共同架设在IP层（网络层）之上。而IP层主要负责的是在节点之间（EndtoEnd）的数据包传送，这里的节点是一台网络设备，比如计算机。因为IP层只负责把数据送到节点，而不能区分上面的不同应用，所以TCP和UDP协议在其基础上加入了端口的信息，端口于是标识的是一个节点上的一个应用。除了增加端口信息，UPD协议基本就没有对IP层的数据进行任何的处理了。而TCP协议还加入了更加复杂的传输控制，比如滑动的数据发送窗口（SliceWindow），以及接收确认和重发机制，以达到数据的可靠传送。不管应用层看到的是怎样一个稳定的TCP数据流，下面传送的都是一个个的IP数据包，需要由TCP协议来进行数据重组。所以，我有理由怀疑，防火墙并没有足够的信息判断TCP数据包的信息，除了IP地址和端口号。而且，我们也看到，所谓的端口，是为了区分不同的应用的，以在不同的IP包来到的时候能够正确转发。TCP/IP只是一个协议栈，就像操作系统的运行机制一样，必须要具体实现，同时还要提供对外的操作接口。就像操作系统会提供标准的编程接口，比如Win 编程接口一样，TCP/IP也必须对外提供编程接口，这就是Socket编程接口--原来是这么回事啊！在Socket编程接口里，设计者提出了一个很重要的概念，那就是socket。这个socket跟文件句柄很相似，实际上在BSD系统里就是跟文件句柄一样存放在一样的进程句柄表里。这个socket其实是一个序号，表示其在句柄表中的位置。这一点，我们已经见过很多了，比如文件句柄，窗口句柄等等。这些句柄，其实是代表了系统中的某些特定的对象，用于在各种函数中作为参数传入，以对特定的对象进行操作--这其实是C语言的问题，在C++语言里，这个句柄其实就是this指针，实际就是对象指针啦。现在我们知道，socket跟TCP/IP并没有必然的联系。Socket编程接口在设计的时候，就希望也能适应其他的网络协议。所以，socket的出现只是可以更方便的使用TCP/IP协议栈而已，其对TCP/IP进行了抽象，形成了几个最基本的函数接口。比如create，listen，accept，connect，read和write等等。现在我们明白，如果一个程序创建了一个socket，并让其监听 端口，其实是向TCP/IP协议栈声明了其对 端口的占有。以后，所有目标是 端口的TCP数据包都会转发给该程序（这里的程序，因为使用的是Socket编程接口，所以首先由Socket层来处理）。所谓accept函数，其实抽象的是TCP的连接建立过程。accept函数返回的新socket其实指代的是本次创建的连接，而一个连接是包括两部分信息的，一个是源IP和源端口，另一个是宿IP和宿端口。所以，accept可以产生多个不同的socket，而这些socket里包含的宿IP和宿端口是不变的，变化的只是源IP和源端口。这样的话，这些socket宿端口就可以都是 ，而Socket层还是能根据源/宿对来准确地分辨出IP包和socket的归属关系，从而完成对TCP/IP协议的操作封装！而同时，放火墙的对IP包的处理规则也是清晰明了，不存在前面设想的种种复杂的情形。