本站提供最佳asp对联广告源码服务，欢迎转载和分享。 本站提供最佳asp对联广告源码服务，欢迎转载和分享。 
1.几个代码伪装成高级黑客
2.linux下socket 网络编程(客户端向服务器端发送文件) 求源代码 大哥大姐帮帮忙 。编程编程。源码谢谢
3.从Linux源码看Socket(TCP)的代码listen及连接队列
4.2024年度Linux6.9内核最新源码解读-网络篇-server端-第一步创建--socket
5.一文从linux源码看socket的close基本概括
6.linux下socket 网络编程(客户端向服务器端发送文件) 求源代码 大哥大姐帮帮忙 ,。。编程编程谢谢
几个代码伪装成高级黑客
1. Introduction
作为计算机科学领域中最为著名的源码职业之一，黑客在当前的代码cesium源码扩展shader网络时代中有着不可忽视的作用。高级黑客更是编程编程其中的佼佼者，他们不仅具备了深厚的源码计算机技术知识，更能够使用各种技术手段，代码无中生有、编程编程突破困境、源码扰乱秩序等，代码令人望尘莫及。编程编程本文将会介绍一些简单的源码代码，让大家了解如何通过伪装成高级黑客，代码获得与众不同、且备受他人崇拜的感受。
2. 建立IP连接
在Python中，我们可以使用socket库来建立一个IP连接，并实现从目标服务器上获取数据的操作，下面是一段伪装成高级黑客的代码：
```python
import socket
def conn(IP, Port):
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect((IP,Port))
while True:
data = client.recv()
print (\'receive:\', data.decode()) #将获取到的数据进行解码
client.send(\'ACK!\'.encode()) #发送一个确认信息
if __name__ == \'__main__\':
conn(\'.0.0.1\', )
```
通过以上代码，我们可以连接到指定的服务器和对应的端口，获取到服务器发送的数据，并且能够对服务器返回一份确认信息，同时也向别人表现出伪装成高级黑客，开源短信平台源码游刃有余的状态。
3. 文件域修改
文件域修改是黑客行业中非常重要的一环，它可以改变一个可编辑文件中特定寻址位置的值。这个方法可以被用来对各种各样的文件（如二进制文件）进行操控。下列的Python代码可以让你的伪装更加漂亮：
```python
import struct
import os
def change_value(file_path, offset, value):
with open(file_path, \"r+b\") as f:
f.seek(offset)
f.write(struct.pack(\'i\', value))
if __name__ == \"__main__\":
file_path = \"/etc/hosts\"
offset =
value =
change_value(file_path, offset, value)
```
以上代码用到了struct结构体和os模块，使用`r+`文件模式打开指定的文件，通过file.seek()方法改变寻址位置，最后使用`struct.pack()`方法打包整数，并使用write()方法写入文件中。当写入完成后，文件中的值也随之更改。这时，你已成为了一个擅长黑客技术的“高手”。
4. 网络嗅探
网络嗅探是指在一个网络中抓取和记录经过网络的信息，并对这些信息进行分析。在现代网络安全领域中，网络嗅探被广泛地应用于网络审计和攻击检测。下面是一个伪装成高级黑客的Python代码示例，可以用于嗅探TCP流量包：
```python
import socket
def sniffTCP(port):
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
sock.bind((\'.0.0.1\', port))
while True:
packet = sock.recvfrom()[0]
ip_header = packet[0:]
tcp_header = packet[:]
print(\"TCP Source Port: %d\" % ord(tcp_header[0]))
except KeyboardInterrupt:
print(\'Interrupted.\')
if __name__ == \"__main__\":
sniffTCP()
```
上述程序使用Python的socket库来监听指定的端口，收集包含TCP流量的数据报，并在控制台输出源端口号。此时，你已经成为一个懂得TCP嗅探技术的黑客了。
5. 爬取网页信息
网络爬虫被广泛用于百度和谷歌搜索引擎中，数据精灵授权源码通过分析网页的源代码，检查网站的链接，实现数据抓取和分析。下面是一个伪装成高级黑客的Python代码示例，可以用于网页爬取，我们可以把以前熟悉的requests库和xpath技术结合运用。
```python
import requests
from lxml import html
def get_info(url):
page = requests.get(url)
tree = html.fromstring(page.content)
title = tree.xpath(\'//title\')[0].text_content()
print(\'Website Title:\', title)
links = tree.xpath(\'//a/@href\')
print(\'Links:\')
for link in links:
print(link)
if __name__ == \'__main__\':
get_info(\'tl.h>
#include <sys/wait.h>
#define MAXDATASIZE
#define SERVPORT
#define BACKLOG
int SendFileToServ(const char *path, const char *FileName, const char *ip)
{
#define PORT
int sockfd;
int recvbytes;
char buf[MAXDATASIZE];
char send_str[MAXDATASIZE];
char filepath[] = { 0};
struct sockaddr_in serv_addr;
FILE *fp;
sprintf(filepath, "%s%s", path, FileName);
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket");
return 1;
}
bzero(&serv_addr,sizeof(struct sockaddr_in));
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(PORT);
inet_aton(ip, &serv_addr.sin_addr);
int IErrCount = 0;
again:
if(connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(struct sockaddr))==-1)
{
if (5 == IErrCount)
return 1;
IErrCount++;
perror("connect");
sleep(2);
goto again;
}
//if ((fp = fopen(FileName, "rb")) == NULL)
if ((fp = fopen(filepath, "rb")) == NULL)
{
perror("fopen ");
return 1;
}
recvbytes = write(sockfd, FileName, strlen(FileName));
recvbytes = read(sockfd, buf, MAXDATASIZE);
if (!memcmp(buf, "sendmsg", 7))
{
while(fgets(send_str, MAXDATASIZE, fp))
{
recvbytes = write(sockfd, send_str, strlen(send_str));
recvbytes = read(sockfd, buf, MAXDATASIZE);
if (recvbytes <= 0)
{
fclose(fp);
close(sockfd);
return 1;
}
if (memcmp(buf, "goon", 4))
{
fclose(fp);
close(sockfd);
return 1;
}
}
recvbytes = write(sockfd, "end", 3);
}
else
{
fclose(fp);
close(sockfd);
return 1;
}
memset(buf, 0, MAXDATASIZE);
if (read(sockfd, buf, MAXDATASIZE) <= 0)
{
close(sockfd);
return 2;
}
char *Eptr = "nginx reload error";
//printf("bf[%s]\n", buf);
int ret;
ret = strncmp(buf, Eptr, strlen(Eptr));
//printf("%d\n", ret);
if (!ret)
{
close(sockfd);
return 2;
}
close(sockfd);
return 0;
}
int mysyslog(const char * msg)
{
FILE *fp;
if ((fp = fopen("/tmp/tmp.log", "a+")) == NULL)
{
return 0;
}
fprintf(fp, "[%s]\n", msg);
fclose(fp);
return 0;
}
static void quit_handler(int signal)
{
kill(0, SIGUSR2);
syslog( LOG_NOTICE, "apuserv quit...");
// do something exit thing ,such as close socket ,close mysql,free list
// .....
//i end
exit(0);
}
static int re_conf = 0;
static void reconf_handler(int signal)
{
re_conf=1;
syslog(LOG_NOTICE,"apuserv reload configure file .");
// 请在循环体中判断，如果re_conf == 1，请再次加载配置文件。
}
static int isrunning(void)
{
int fd;
int ret;
struct flock lock;
lock.l_type = F_WRLCK;
lock.l_whence = 0;
lock.l_start = 0;
lock.l_len = 0;
const char *lckfile = "/tmp/apuserv.lock";
fd = open(lckfile,O_WRONLY|O_CREAT);
if (fd < 0) {
syslog(LOG_ERR,"can not create lock file: %s\n",lckfile);
return 1;
}
if ((ret = fcntl(fd,F_SETLK,&lock)) < 0) {
ret = fcntl(fd,F_GETLK,&lock);
if (lock.l_type != F_UNLCK) {
close(fd);
return lock.l_pid;
}
else {
fcntl(fd,F_SETLK,&lock);
}
}
return 0;
}
int MyHandleBuff(const char *buf, char *str, char *FileName, char *pth)
{
sscanf(buf, "%s %s %s", pth, FileName, str);
printf("path=%s\nfilename=%s\nip=%s\n", pth, FileName, str);
return 0;
}
int main(int argc, char **argv)
{
int sockfd,client_fd;
socklen_t sin_size;
struct sockaddr_in my_addr,remote_addr;
char buff[MAXDATASIZE];
int recvbytes;
#if 1
int pid ;
char ch ;
int ret;
int debug = 0;
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGTERM, quit_handler);
syslog(LOG_NOTICE,"apuserver start....");
while ((ch = getopt(argc, argv, "dhV")) != -1) {
switch (ch) {
case 'd':
debug = 1;
break;
case 'V':
printf("Version:%s\n","1.0.0");
return 0;
case 'h':
printf(" -d use daemon mode\n");
printf(" -V show version\n");
return 0;
default:
printf(" -d use daemon mode\n");
printf(" -V show version\n");
}
}
if (debug && daemon(0,0 ) ) {
return -1;
}
if (isrunning()) {
fprintf(stderr, "apuserv is already running\n");
syslog(LOG_INFO,"apuserv is already running\n");
exit(0);
}
while (1) {
pid = fork();
if (pid < 0)
return -1;
if (pid == 0)
break;
while ((ret = waitpid(pid, NULL, 0)) != pid) {
syslog(LOG_NOTICE, "waitpid want %d, but got %d", pid, ret);
if (ret < 0)
syslog(LOG_NOTICE, "waitpid errno:%d", errno);
}
kill(0, SIGUSR2);
sleep(1);
syslog(LOG_NOTICE,"restart apuserver");
}
signal(SIGHUP, reconf_handler);
signal(SIGPIPE, SIG_IGN);
signal(SIGUSR1,SIG_IGN);
signal(SIGUSR2, SIG_DFL);
signal(SIGTERM, SIG_DFL);
#endif
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket");
exit(1);
}
bzero(&my_addr,sizeof(struct sockaddr_in));
my_addr.sin_family=AF_INET;
my_addr.sin_port=htons(SERVPORT);
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)
{
perror("bind");
exit(1);
}
if(listen(sockfd,BACKLOG)==-1)
{
perror("listen");
exit(1);
}
int nret;
while(1)
{
sin_size = sizeof(struct sockaddr_in);
if((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size))==-1)
{
perror("falied accept");
continue;
}
memset(buff, 0, MAXDATASIZE);
recvbytes = read(client_fd, buff, MAXDATASIZE);
char str[] = { 0};
char FileName[] = { 0};
char path[] = { 0};
MyHandleBuff(buff, str, FileName, path);
if (recvbytes > 0)
{
nret = SendFileToServ(path, FileName, str);
printf("nret[%d]\n", nret);
if (1 == nret)
write(client_fd, "send file error", );
else if(2 == nret)
write(client_fd, "reload nginx error", );
else
write(client_fd, "succ", 4);
}
close(client_fd);
}
}
_________________________________________________
client:
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <syslog.h>
#include <sys/time.h>
#include <string.h>
#include <fcntl.h>
#include <sys/wait.h>
#define MAXDATASIZE
#define SERVPORT
#define BACKLOG
int mysyslog(const char * msg)
{
FILE *fp;
if ((fp = fopen("/tmp/tmp.log", "a+")) == NULL)
{
return 0;
}
fprintf(fp, "[%s]\n", msg);
fclose(fp);
return 0;
}
static void quit_handler(int signal)
{
kill(0, SIGUSR2);
syslog( LOG_NOTICE, "apuserv quit...");
// do something exit thing ,such as close socket ,close mysql,free list
// .....
//i end
exit(0);
}
static int re_conf = 0;
static void reconf_handler(int signal)
{
re_conf=1;
syslog(LOG_NOTICE,"apuserv reload configure file .");
// ·1nf == 1￡′μ?
static int isrunning(void)
{
int fd;
int ret;
struct flock lock;
lock.l_type = F_WRLCK;
lock.l_whence = 0;
lock.l_start = 0;
lock.l_len = 0;
const char *lckfile = "/tmp/dstserver.lock";
fd = open(lckfile,O_WRONLY|O_CREAT);
if (fd < 0) {
syslog(LOG_ERR,"can not create lock file: %s\n",lckfile);
return 1;
}
if ((ret = fcntl(fd,F_SETLK,&lock)) < 0) {
ret = fcntl(fd,F_GETLK,&lock);
if (lock.l_type != F_UNLCK) {
close(fd);
return lock.l_pid;
}
else {
fcntl(fd,F_SETLK,&lock);
}
}
return 0;
}
int main(int argc, char **argv)
{
int sockfd,client_fd;
socklen_t sin_size;
struct sockaddr_in my_addr,remote_addr;
char buff[MAXDATASIZE];
int recvbytes;
#if 1
int pid ;
char ch ;
int ret;
int debug = 0;
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGTERM, quit_handler);
syslog(LOG_NOTICE,"dstserver start....");
while ((ch = getopt(argc, argv, "dhV")) != -1) {
switch (ch) {
case 'd':
debug = 1;
break;
case 'V':
printf("Version:%s\n","1.0.0");
return 0;
case 'h':
printf(" -d use daemon mode\n");
printf(" -V show version\n");
return 0;
default:
printf(" -d use daemon mode\n");
printf(" -V show version\n");
}
}
if (debug && daemon(0,0 ) ) {
return -1;
}
if (isrunning()) {
fprintf(stderr, "dstserver is already running\n");
syslog(LOG_INFO,"dstserver is already running\n");
exit(0);
}
while (1) {
pid = fork();
if (pid < 0)
return -1;
if (pid == 0)
break;
while ((ret = waitpid(pid, NULL, 0)) != pid) {
syslog(LOG_NOTICE, "waitpid want %d, but got %d", pid, ret);
if (ret < 0)
syslog(LOG_NOTICE, "waitpid errno:%d", errno);
}
kill(0, SIGUSR2);
sleep(1);
syslog(LOG_NOTICE,"restart apuserver");
}
signal(SIGHUP, reconf_handler);
signal(SIGPIPE, SIG_IGN);
signal(SIGUSR1,SIG_IGN);
signal(SIGUSR2, SIG_DFL);
signal(SIGTERM, SIG_DFL);
#endif
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket");
exit(1);
}
bzero(&my_addr,sizeof(struct sockaddr_in));
my_addr.sin_family=AF_INET;
my_addr.sin_port=htons(SERVPORT);
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)
{
perror("bind");
exit(1);
}
if(listen(sockfd,BACKLOG)==-1)
{
perror("listen");
exit(1);
}
char filepath[MAXDATASIZE]= { 0};
FILE *fp;
while(1)
{
sin_size = sizeof(struct sockaddr_in);
if((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size))==-1)
{
perror("falied accept");
continue;
}
memset(buff, 0, MAXDATASIZE);
recvbytes = read(client_fd, buff, MAXDATASIZE);
sprintf(filepath, "/etc/nginx/url_rule/%s", buff);
if ((fp = fopen(filepath, "wb")) == NULL)
{
perror("fopen");
close(client_fd);
continue;
}
write(client_fd, "sendmsg", 7);
while(read(client_fd, buff, MAXDATASIZE))
{
if (!memcmp(buff, "end", 3))
{
fclose(fp);
break;
}
else
{
fprintf(fp, "%s", buff);
write(client_fd, "goon", 4);
}
}
//system("nginx -s reload");
char *Sptr = "nginx reload succ";
char *Eptr = "nginx reload error";
int ret;
ret = system("nginx -s reload");
printf("ret[%d]\n", ret);
if (ret != 0)
{
write(client_fd, Eptr, strlen(Eptr));
}
else
{
write(client_fd, Sptr, strlen(Sptr));
}
close(client_fd);
}
}
以前写的：内容忘记了。不是很复杂你可以自己看！
从Linux源码看Socket(TCP)的listen及连接队列
了解Linux内核中Socket (TCP)的"listen"及连接队列机制是深入理解网络编程的关键。本文将基于Linux 3.内核版本，从源码角度解析Server端Socket在进行"listen"时的具体实现。
建立Server端Socket需要经历socket、bind、listen、accept四个步骤。本文聚焦于"listen"步骤，深入探讨其内部机理。
通过socket系统调用，我们可以创建一个基于TCP的Socket。这里直接展示了与TCP Socket相关联的操作函数。
接着，互动虚拟试衣源码我们深入到"listen"系统调用。注意，glibc的INLINE_SYSCALL对返回值进行了封装，仅保留0和-1两种结果，并将错误码的绝对值记录在errno中。其中，backlog参数至关重要，设置不当会引入隐蔽的陷阱。对于Java开发者而言，框架默认backlog值较小（默认），这可能导致微妙的行为差异。
进入内核源码栈，我们发现内核对backlog值进行了调整，限制其不超过内核参数设置的somaxconn值。
核心调用程序为inet_listen。其中，除了fastopen外的逻辑（fastopen将在单独章节深入讨论）最终调用inet_csk_listen_start，将sock链入全局的listen hash表，实现对SYN包的高效处理。
值得注意的是，SO_REUSEPORT特性允许不同Socket监听同一端口，实现内核级的负载均衡。Nginx 1.9.1版本启用此功能后，性能提升3倍。android闹钟源码 下载
半连接队列与全连接队列是连接处理中的关键组件。通常提及的sync_queue与accept_queue并非全貌，sync_queue实际上是syn_table，而全连接队列为icsk_accept_queue。在三次握手过程中，这两个队列分别承担着不同角色。
在连接处理中，除了qlen与sk_ack_backlog计数器外，qlen_young计数器用于特定场景下的统计。SYN_ACK的重传定时器在内核中以ms为间隔运行，确保连接建立过程的稳定。
半连接队列的存在是为抵御半连接攻击，避免消耗大量内存资源。通过syn_cookie机制，内核能有效防御此类攻击。
全连接队列的最大长度受到限制，超过somaxconn值的连接会被内核丢弃。若未启用tcp_abort_on_overflow特性，客户端可能在调用时才会察觉到连接被丢弃。启用此特性或增大backlog值是应对这一问题的策略。
backlog参数对半连接队列容量产生影响，导致内核发送cookie校验时出现常见的内存溢出警告。
总结而言，TCP协议在数十年的演进中变得复杂，深入阅读源码成为分析问题的重要途径。本文深入解析了Linux内核中Socket (TCP)的"listen"及连接队列机制，旨在帮助开发者更深入地理解网络编程。
年度Linux6.9内核最新源码解读-网络篇-server端-第一步创建--socket
深入解析年Linux 6.9内核的网络篇，从服务端的第一步：创建socket开始。理解用户空间与内核空间的交互至关重要。当我们在用户程序中调用socket(AF_INET, SOCK_STREAM, 0)，实际上是触发了从用户空间到内核空间的系统调用sys_socket()，这是创建网络连接的关键步骤。 首先，让我们关注sys_socket函数。这个函数在net/socket.c文件的位置，无论内核版本如何，都会调用__sys_socket_create函数来实际创建套接字，它接受地址族、类型、协议和结果指针。创建失败时，会返回错误指针。 在socket创建过程中，参数解析至关重要：网络命名空间（net）：隔离网络环境，每个空间有自己的配置，如IP地址和路由。
协议族（family）：如IPv4（AF_INET）或IPv6（AF_INET6）。
套接字类型（type）：如流式（SOCK_STREAM）或数据报（SOCK_DGRAM）。
协议（protocol）：如TCP（IPPROTO_TCP）或UDP（IPPROTO_UDP），默认值自动选择。
结果指针（res）：指向新创建的socket结构体。
内核标志（kern）：区分用户空间和内核空间的socket。
__sock_create函数处理创建逻辑，调用sock_map_fd映射文件描述符，支持O_CLOEXEC和O_NONBLOCK选项。每个网络协议族有其特有的create函数，如inet_create处理IPv4 TCP创建。 在内核中，安全模块如LSM会通过security_socket_create进行安全检查。sock_alloc负责内存分配和socket结构初始化，协议族注册和动态加载在必要时进行。RCU机制保护数据一致性，确保在多线程环境中操作的正确性。 理解socket_wq结构体对于异步IO至关重要，它协助socket管理等待队列和通知。例如，在TCP协议族的inet_create函数中，会根据用户请求找到匹配的协议，并设置相关的操作集和数据结构。 通过源码，我们可以看到socket和sock结构体的关系，前者是用户空间操作的抽象，后者是内核处理网络连接的实体。理解这些细节有助于我们更好地编写C++网络程序。 此外，原始套接字（如TCP、UDP和CMP）的应用示例，以及对不同协议的深入理解，如常用的IP协议、专用协议和实验性协议，是进一步学习和实践的重要部分。一文从linux源码看socket的close基本概括
理解TCP关闭过程的关键在于四次挥手，这个过程是主动关闭、被动关闭和同时关闭的统一体现。在主动关闭close(fd)的过程中，通过C语言中的close(int fd)函数调用系统调用sys_close，进而执行filp_close方法。随后，fput函数处理多进程中的socket引用问题，确保父进程也正确关闭socket。在f_op->release的实现中，我们关注socket与file的关系以及close(fd)调用链。随着状态机的变迁，TCP从FIN_WAIT1变迁至FIN_WAIT2，设置一个TCP_FIN_WAIT2定时器，防止由于对端未回应导致的长时间等待。FIN_WAIT2状态等待对端的FIN，完成最后两次挥手。接收对端FIN后，状态变化至time_wait，原socket资源被回收，并在时间等待超时后从系统中清除。在被动关闭中，接收FIN进入close_wait状态，应用关闭连接时改变状态为last_ack，并发送本端的FIN。被动关闭的后两次挥手后，连接关闭。出现大量close_wait通常与应用检测到对端FIN时未及时关闭有关，解决方法包括调整连接池的参数或加入心跳检测。操作系统通过包活定时器在超时后强制关闭连接。进程退出时会关闭所有文件描述符，再次触发filp_close函数。在Java中，通过重写finalize方法，GC会在释放内存时关闭未被引用的socket，但不可完全依赖GC来管理socket资源，以避免潜在的内存泄露问题。总结，深入理解TCP关闭过程有助于优化网络应用程序的性能和稳定性，同时阅读Linux内核源代码需要耐心和系统性的方法。
linux下socket 网络编程(客户端向服务器端发送文件) 求源代码 大哥大姐帮帮忙 ,。。谢谢
源代码奉上，流程图。。。这个太简单了，你自己看看。。。。。。。
//TCP
//服务器端程序
#include< stdio.h >
#include< stdlib.h >
#include< windows.h >
#include< winsock.h >
#include< string.h >
#pragma comment( lib, "ws2_.lib" )
#define PORT
#define BACKLOG
#define TRUE 1
void main( void )
{
int iServerSock;
int iClientSock;
char *buf = "hello, world!\n";
struct sockaddr_in ServerAddr;
struct sockaddr_in ClientAddr;
int sin_size;
WSADATA WSAData;
if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )//初始化
{
printf( "initializationing error!\n" );
WSACleanup( );
exit( 0 );
}
if( ( iServerSock = socket( AF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )
{
printf( "创建套接字失败!\n" );
WSACleanup( );
exit( 0 );
}
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons( PORT );//监视的端口号
ServerAddr.sin_addr.s_addr = INADDR_ANY;//本地IP
memset( & ( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );
if( bind( iServerSock, ( struct sockaddr * )&ServerAddr, sizeof( struct sockaddr ) ) == -1 )
{
printf( "bind调用失败!\n" );
WSACleanup( );
exit( 0 );
}
if( listen( iServerSock, BACKLOG ) == -1 )
{
printf( "listen调用失败!\n" );
WSACleanup( );
exit( 0 );
}
while( TRUE )
{
sin_size = sizeof( struct sockaddr_in );
iClientSock = accept( iServerSock, ( struct sockaddr * )&ClientAddr, &sin_size );
if( iClientSock == -1 )
{
printf( "accept调用失败!\n" );
WSACleanup( );
exit( 0 );
}
printf( "服务器连接到%s\n", inet_ntoa( ClientAddr.sin_addr ) );
if( send( iClientSock, buf, strlen( buf ), 0 ) == -1 )
{
printf( "send调用失败!" );
closesocket( iClientSock );
WSACleanup( );
exit( 0 );
}
}
}
/////客户端程序
#include< stdio.h >
#include< stdlib.h >
#include< windows.h >
#include< winsock.h >
#include< string.h >
#pragma comment( lib, "ws2_.lib" )
#define PORT
#define BACKLOG
#define TRUE 1
#define MAXDATASIZE
void main( void )
{
int iClientSock;
char buf[ MAXDATASIZE ];
struct sockaddr_in ServerAddr;
int numbytes;
// struct hostent *he;
WSADATA WSAData;
// int sin_size;
/* if( ( he = gethostbyname( "liuys" ) ) == NULL )
{
printf( "gethostbyname调用失败!" );
WSACleanup( );
exit( 0 );
}
*/
if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )//初始化
{
printf( "initializationing error!\n" );
WSACleanup( );
exit( 0 );
}
if( ( iClientSock = socket( AF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )
{
printf( "创建套接字失败!\n" );
WSACleanup( );
exit( 0 );
}
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons( PORT );
// ServerAddr.sin_addr = *( ( struct in_addr * )he->h_addr );
ServerAddr.sin_addr.s_addr = inet_addr( "..2." );//记得换IP
memset( &( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );
if( connect( iClientSock, ( struct sockaddr * ) & ServerAddr, sizeof( struct sockaddr ) ) == -1 )
{
printf( "connect失败!" );
WSACleanup( );
exit( 0 );
}
numbytes = recv( iClientSock, buf, MAXDATASIZE, 0 );
if( numbytes == -1 )
{
printf( "recv失败!" );
WSACleanup( );
exit( 0 );
}
buf[ numbytes ] = '\0';
printf( "Received: %s", buf );
closesocket( iClientSock );
WSACleanup( );
}
/////UDP
//服务器
#include< stdio.h >
#include< string.h >
#include< winsock.h >
#include< windows.h >
#pragma comment( lib, "ws2_.lib" )
#define PORT
#define BACKLOG
#define TRUE 1
#define MAXDATASIZE
void main( void )
{
int iServerSock;
// int iClientSock;
int addr_len;
int numbytes;
char buf[ MAXDATASIZE ];
struct sockaddr_in ServerAddr;
struct sockaddr_in ClientAddr;
WSADATA WSAData;
if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )
{
printf( "initializationing error!\n" );
WSACleanup( );
exit( 0 );
}
iServerSock = socket( AF_INET, SOCK_DGRAM, 0 );
if( iServerSock == INVALID_SOCKET )
{
printf( "创建套接字失败!\n" );
WSACleanup( );
exit( 0 );
}
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons( PORT );//监视的端口号
ServerAddr.sin_addr.s_addr = INADDR_ANY;//本地IP
memset( & ( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );
if( bind( iServerSock, ( struct sockaddr * )&ServerAddr, sizeof( struct sockaddr ) ) == -1 )
{
printf( "bind调用失败!\n" );
WSACleanup( );
exit( 0 );
}
addr_len = sizeof( struct sockaddr );
numbytes = recvfrom( iServerSock, buf, MAXDATASIZE, 0, ( struct sockaddr * ) & ClientAddr, &addr_len );
if( numbytes == -1 )
{
printf( "recvfrom调用失败!\n" );
WSACleanup( );
exit( 0 );
}
printf( "got packet from %s\n", inet_ntoa( ClientAddr.sin_addr ) );
printf( "packet is %d bytes long\n", numbytes );
buf[ numbytes ] = '\0';
printf( "packet contains \"%s\"\n", buf );
closesocket( iServerSock );
WSACleanup( );
}
//客户端
#include< stdio.h >
#include< stdlib.h >
#include< windows.h >
#include< winsock.h >
#include< string.h >
#pragma comment( lib, "ws2_.lib" )
#define PORT
#define MAXDATASIZE
void main( void )
{
int iClientSock;
struct sockaddr_in ServerAddr;
int numbytes;
char buf[ MAXDATASIZE ] = { 0 };
WSADATA WSAData;
if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )
{
printf( "initializationing error!\n" );
WSACleanup( );
exit( 0 );
}
if( ( iClientSock = socket( AF_INET, SOCK_DGRAM, 0 ) ) == -1 )
{
printf( "创建套接字失败!\n" );
WSACleanup( );
exit( 0 );
}
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons( PORT );
ServerAddr.sin_addr.s_addr = inet_addr( "..2." );//记得换IP
memset( &( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );
numbytes = sendto( iClientSock, buf, strlen( buf ), 0, ( struct sockaddr * ) & ServerAddr, sizeof( struct sockaddr ) );
if( numbytes == -1 )
{
printf( "sendto调用失败!\n" );
WSACleanup( );
exit( 0 );
}
printf( "sent %d bytes to %s\n", numbytes, inet_ntoa( ServerAddr.sin_addr ) );
closesocket( iClientSock );
WSACleanup( );
}
