sockettool源代码（sockettool下载）

本篇文章给大家谈谈sockettool源代码，以及sockettool下载对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、Android socket源码解析(三)socket的connect源码解析
• 2、在Android端使用socket传输图片到java服务器，求源代码
• 3、SocketTool怎么用/如何建立Socket服务端/客户端
• 4、linux下socket 网络编程(客户端向服务器端发送文件) 求源代码 大哥大姐帮帮忙 。。谢谢

Android socket源码解析(三)socket的connect源码解析

上一篇文章着重的聊了socket服务端的bind，listen，accpet的逻辑。本文来着重聊聊connect都做了什么？

如果遇到什么问题，可以来本文 下讨论

当服务端一切都准备好了。客户端就会尝试的通过 connect 系统调用，尝试的和服务端建立远程连接。

首先校验当前socket中是否有正确的目标地址。然后获取IP地址和端口调用 connectToAddress 。

在这个方法中，能看到有一个 NetHooks 跟踪socket的调用，也能看到 BlockGuard 跟踪了socket的connect调用。因此可以hook这两个地方跟踪socket，不过很少用就是了。

核心方法是 socketConnect 方法，这个方法就是调用 IoBridge.connect 方法。同理也会调用到jni中。

能看到也是调用了 connect 系统调用。

文件：/ net / ipv4 / af_inet.c

在这个方法中做的事情如下：

注意 sk_prot 所指向的方法是， tcp_prot 中 connect 所指向的方法，也就是指 tcp_v4_connect .

文件：/ net / ipv4 / tcp_ipv4.c

本质上核心任务有三件:

想要能够理解下文内容，先要明白什么是路由表。

路由表分为两大类：

每个路由器都有一个路由表(RIB)和转发表 (fib表)，路由表用于决策路由，转发表决策转发分组。下文会接触到这两种表。

这两个表有什么区别呢？

网上虽然给了如下的定义：

但实际上在Linux 3.8.1中并没有明确的区分。整个路由相关的逻辑都是使用了fib转发表承担的。

先来看看几个和FIB转发表相关的核心结构体：

熟悉Linux命令朋友一定就能认出这里面大部分的字段都可以通过route命令查找到。

命令执行结果如下：

在这route命令结果的字段实际上都对应上了结构体中的字段含义：

知道路由表的的内容后。再来FIB转发表的内容。实际上从下面的源码其实可以得知，路由表的获取，实际上是先从fib转发表的路由字典树获取到后在同感加工获得路由表对象。

转发表的内容就更加简单

还记得在之前总结的ip地址的结构吗？

需要进行一次tcp的通信，意味着需要把ip报文准备好。因此需要决定源ip地址和目标IP地址。目标ip地址在之前通过netd查询到了，此时需要得到本地发送的源ip地址。

然而在实际情况下，往往是面对如下这么情况：公网一个对外的ip地址，而内网会被映射成多个不同内网的ip地址。而这个过程就是通过DDNS动态的在内存中进行更新。

因此 ip_route_connect 实际上就是选择一个缓存好的，通过DDNS设置好的内网ip地址并找到作为结果返回，将会在之后发送包的时候填入这些存在结果信息。而查询内网ip地址的过程，可以成为RTNetLink。

在Linux中有一个常用的命令 ifconfig 也可以实现类似增加一个内网ip地址的功能：

比如说为网卡eth0增加一个IPV6的地址。而这个过程实际上就是调用了devinet内核模块设定好的添加新ip地址方式，并在回调中把该ip地址刷新到内存中。

注意 devinet 和 RTNetLink 严格来说不是一个存在同一个模块。虽然都是使用 rtnl_register 注册方法到rtnl模块中：

文件：/ net / ipv4 / devinet.c

文件：/ net / ipv4 / route.c

实际上整个route模块，是跟着ipv4 内核模块一起初始化好的。能看到其中就根据不同的rtnl操作符号注册了对应不同的方法。

整个DDNS的工作流程大体如下：

当然，在tcp三次握手执行之前，需要得到当前的源地址，那么就需要通过rtnl进行查询内存中分配的ip。

文件：/ include / net / route.h

这个方法核心就是 __ip_route_output_key .当目的地址或者源地址有其一为空，则会调用 __ip_route_output_key 填充ip地址。目的地址为空说明可能是在回环链路中通信，如果源地址为空，那个说明可能往目的地址通信需要填充本地被DDNS分配好的内网地址。

在这个方法中核心还是调用了 flowi4_init_output 进行flowi4结构体的初始化。

文件：/ include / net / flow.h

能看到这个过程把数据中的源地址，目的地址，源地址端口和目的地址端口，协议类型等数据给记录下来，之后内网ip地址的查询与更新就会频繁的和这个结构体进行交互。

能看到实际上 flowi4 是一个用于承载数据的临时结构体，包含了本次路由操作需要的数据。

执行的事务如下：

想要弄清楚ip路由表的核心逻辑，必须明白路由表的几个核心的数据结构。当然网上搜索到的和本文很可能大为不同。本文是基于LInux 内核3.1.8.之后的设计几乎都沿用这一套。

而内核将路由表进行大规模的重新设计，很大一部分的原因是网络环境日益庞大且复杂。需要全新的方式进行优化管理系统中的路由表。

下面是fib_table 路由表所涉及的数据结构：

依次从最外层的结构体介绍：

能看到路由表的存储实际上通过字典树的数据结构压缩实现的。但是和常见的字典树有点区别，这种特殊的字典树称为LC-trie 快速路由查找算法。

这一篇文章对于快速路由查找算法的理解写的很不错:

首先理解字典树：字典树简单的来说，就是把一串数据化为二进制格式，根据左0，右1的方式构成的。

如图下所示：

这个过程用图来展示，就是沿着字典树路径不断向下读，比如依次读取abd节点就能得到00这个数字。依次读取abeh就能得到010这个数字。

说到底这种方式只是存储数据的一种方式。而使用数的好处就能很轻易的找到公共前缀，在字典树中找到公共最大子树，也就找到了公共前缀。

而LC-trie 则是在这之上做了压缩优化处理，想要理解这个算法，必须要明白在 tnode 中存在两个十分核心的数据：

这负责什么事情呢？下面就简单说说整个lc-trie的算法就能明白了。

当然先来看看方法 __ip_dev_find 是如何查找

文件：/ net / ipv4 / fib_trie.c

整个方法就是通过 tkey_extract_bits 生成tnode中对应的叶子节点所在index，从而通过 tnode_get_child_rcu 拿到tnode节点中index所对应的数组中获取叶下一级别的tnode或者叶子结点。

其中查找index最为核心方法如上，这个过程，先通过key左移动pos个位，再向右边移动（32 - bits）算法找到对应index。

在这里能对路由压缩算法有一定的理解即可，本文重点不在这里。当从路由树中找到了结果就返回 fib_result 结构体。

查询的结果最为核心的就是 fib_table 路由表，存储了真正的路由转发信息

文件：/ net / ipv4 / route.c

这个方法做的事情很简单，本质上就是想要找到这个路由的下一跳是哪里？

在这里面有一个核心的结构体名为 fib_nh_exception 。这个是指fib表中去往目的地址情况下最理想的下一跳的地址。

而这个结构体在上一个方法通过 find_exception 获得.遍历从 fib_result 获取到 fib_nh 结构体中的 nh_exceptions 链表。从这链表中找到一模一样的目的地址并返回得到的。

文件：/ net / ipv4 / tcp_output.c

在Android端使用socket传输图片到java服务器，求源代码

/**

 * 思想：

 1.直接将所有数据安装字节数组发送

 2.对象序列化方式

 */

/**

 * thread方式

 *

 * @author Administrator

 */

public class TestSocketActivity4 extends Activity {

    private static final int FINISH = 0;

    private Button send = null;

    private TextView info = null;

    private Handler myHandler = new Handler() {

        @Override

        public void handleMessage(Message msg) {

            switch (msg.what) {

                case FINISH:

                    String result = msg.obj.toString(); // 取出数据

                    if ("true".equals(result)) {

                        TestSocketActivity4.this.info.setText("操作成功！");

                    } else {

                        TestSocketActivity4.this.info.setText("操作失败！");

                    }

                    break;

            }

        }

    };

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        super.setContentView(R.layout.activity_test_sokect_activity4);

        // StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()

        // .detectDiskReads().detectDiskWrites().detectNetwork()

        // .penaltyLog().build());

        // StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()

        // .detectLeakedSqlLiteObjects().detectLeakedClosableObjects()

        // .penaltyLog().penaltyDeath().build());

        this.send = (Button) super.findViewById(R.id.send);

        this.info = (TextView) super.findViewById(R.id.info);

        this.send.setOnClickListener(new SendOnClickListener());

    }

    private class SendOnClickListener implements OnClickListener {

        @Override

        public void onClick(View v) {

            try {

                new Thread(new Runnable() {

                    @Override

                    public void run() {

                        try {

                            //1:

                            Socket client = new Socket("192.168.1.165", 9898);

                            //2:

                            ObjectOutputStream oos = new ObjectOutputStream(

                                    client.getOutputStream());

                            //3:

                            UploadFile myFile = SendOnClickListener.this

                                    .getUploadFile();

                            //4:

                            oos.writeObject(myFile);// 写文件对象

                            // oos.writeObject(null);// 避免EOFException

                            oos.close();

                            BufferedReader buf = new BufferedReader(

                                    new InputStreamReader(client

                                            .getInputStream())); // 读取返回的数据

                            String str = buf.readLine(); // 读取数据

                            Message msg = TestSocketActivity4.this.myHandler

                                    .obtainMessage(FINISH, str);

                            TestSocketActivity4.this.myHandler.sendMessage(msg);

                            buf.close();

                            client.close();

                        } catch (Exception e) {

                            Log.i("UploadFile", e.getMessage());

                        }

                    }

                }).start();

            } catch (Exception e) {

                e.printStackTrace();

            }

        }

        private UploadFile getUploadFile() throws Exception { // 包装了传送数据

            UploadFile myFile = new UploadFile();

            myFile.setTitle("tangcco安卓之Socket的通信"); // 设置标题

            myFile.setMimeType("image/png"); // 图片的类型

            File file = new File(Environment.getExternalStorageDirectory()

                    .toString()

                    + File.separator

                    + "Pictures"

                    + File.separator

                    + "b.png");

            InputStream input = null;

            try {

                input = new FileInputStream(file); // 从文件中读取

                ByteArrayOutputStream bos = new ByteArrayOutputStream();

                byte data[] = new byte[1024];

                int len = 0;

                while ((len = input.read(data)) != -1) {

                    bos.write(data, 0, len);

                }

                myFile.setContentData(bos.toByteArray());

                myFile.setContentLength(file.length());

                myFile.setExt("png");

            } catch (Exception e) {

                throw e;

            } finally {

                input.close();

            }

            return myFile;

        }

    }

}

public class UploadFile implements Serializable {

private String title;

private byte[] contentData;

private String mimeType;

private long contentLength;

private String ext;

public String getTitle() {

return title;

}

public void setTitle(String title) {

this.title = title;

}

public byte[] getContentData() {

return contentData;

}

public void setContentData(byte[] contentData) {

this.contentData = contentData;

}

public String getMimeType() {

return mimeType;

}

public void setMimeType(String mimeType) {

this.mimeType = mimeType;

}

public long getContentLength() {

return contentLength;

}

public void setContentLength(long contentLength) {

this.contentLength = contentLength;

}

public String getExt() {

return ext;

}

public void setExt(String ext) {

this.ext = ext;

}

}

下边是服务端

public class Main4 {

public static void main(String[] args) throws Exception {

ServerSocket server = new ServerSocket(9898); // 服务器端端口

System.out.println("服务启动........................");

boolean flag = true; // 定义标记，可以一直死循环

while (flag) { // 通过标记判断循环

new Thread(new ServerThreadUtil(server.accept())).start(); // 启动线程

}

server.close(); // 关闭服务器

}

}

public class ServerThreadUtil implements Runnable {

private static final String DIRPATH = "D:" + File.separator + "myfile"

+ File.separator; // 目录路径

private Socket client = null;

private UploadFile upload = null;

public ServerThreadUtil(Socket client) {

this.client = client;

System.out.println("新的客户端连接...");

}

@Override

public void run() {

try {

ObjectInputStream ois = new ObjectInputStream(

client.getInputStream()); // 反序列化

this.upload = (UploadFile) ois.readObject(); // 读取对象//UploadFile需要和客户端传递过来的包名类名相同，如果不同则会报异常

System.out.println("文件标题：" + this.upload.getTitle());

System.out.println("文件类型：" + this.upload.getMimeType());

System.out.println("文件大小：" + this.upload.getContentLength());

PrintStream out = new PrintStream(this.client.getOutputStream());// BufferedWriter

out.print(this.saveFile());//返回响应

// BufferedWriter writer = null;

// writer.write("");

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

this.client.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

private boolean saveFile() throws Exception { // 负责文件内容的保存

/**

 * java.util.UUID.randomUUID():

 * UUID.randomUUID().toString()是javaJDK提供的一个自动生成主键的方法。 UUID(Universally

 * Unique Identifier)全局唯一标识符,是指在一台机器上生成的数字，它保证对在同一时空中的所有机器都是唯一的，

 * 是由一个十六位的数字组成

 * ,表现出来的形式。由以下几部分的组合：当前日期和时间(UUID的第一个部分与时间有关，如果你在生成一个UUID之后，

 * 过几秒又生成一个UUID，

 * 则第一个部分不同，其余相同)，时钟序列，全局唯一的IEEE机器识别号（如果有网卡，从网卡获得，没有网卡以其他方式获得

 * ），UUID的唯一缺陷在于生成的结果串会比较长，字符串长度为36。

 * 

 * UUID.randomUUID().toString()是java JDK提供的一个自动生成主键的方法。 UUID(Universally

 * Unique Identifier)全局唯一标识符, 是指在一台机器上生成的数字，它保证对在同一时空中的所有机器都是唯一的，

 * 是由一个十六位的数字组成,表现出来的形式

 */

File file = new File(DIRPATH + UUID.randomUUID() + "."

+ this.upload.getExt());

if (!file.getParentFile().exists()) {

file.getParentFile().mkdir();

}

OutputStream output = null;

try {

output = new FileOutputStream(file);

output.write(this.upload.getContentData());

return true;

} catch (Exception e) {

throw e;

} finally {

output.close();

}

}

}

public class UploadFile implements Serializable {

private String title;

private byte[] contentData;

private String mimeType;

private long contentLength;

private String ext;

public String getTitle() {

return title;

}

public void setTitle(String title) {

this.title = title;

}

public byte[] getContentData() {

return contentData;

}

public void setContentData(byte[] contentData) {

this.contentData = contentData;

}

public String getMimeType() {

return mimeType;

}

public void setMimeType(String mimeType) {

this.mimeType = mimeType;

}

public long getContentLength() {

return contentLength;

}

public void setContentLength(long contentLength) {

this.contentLength = contentLength;

}

public String getExt() {

return ext;

}

public void setExt(String ext) {

this.ext = ext;

}

}

SocketTool怎么用/如何建立Socket服务端/客户端

下载完成后，软件是一个单独的运行程序，可以直接打开软件。

3

软件的界面很简单，在左侧有tcp和udp的客户端或服务端的快捷按钮，上方有【创建】【删除】【退出】等选项按钮。

我们先来建立TCP的测试服务端。点击【TCP Server】再点击【创建】。

选择一个监听端口，这里我们使用6001作为服务端的监听端口。

建立完成后，服务端会自动启动，软件会显示【启动监听】的状态。

我们可以检测一下本机的6001端口是否已经打开。在DOS窗口中输入命令【netstat -a】，可以在列表中看到本机的6001端口的状态为listening的状态，表示本机的6001端口正处于监听的状态。

在DOS窗口中输入命令【telnet 192.168.0.140 6001】来登录本地的6001端口。

点击回车键，就可以成功登录6001端口。在测试软件中就可以看到状态是已连接的状态，同时也可以看到对方的ip就是本地ip。

再来测试通信情况，在DOS窗口中输入a、b、c，在软件的接收窗口就可以看到收到的数据了。

在软件的发送窗口中输入1234567890，点击发送后，在DOS窗口中就可以看到软件发送过来的数据了。

测试完成后，在软件中点击【停止监听】，同时在DOS窗口中可以看到【失去了跟主机的连接】，表示测试连接已经断开。

再来创建TCP的客户端，点击【TCP Client】再点击【创建】。会弹出【创建socket客户端】窗口，输入对方的ip和对方的端口，点击确认。

14

tcp的客户端已经建立好，如果对方的端口监听正常的话，点击【连接】就可以连接到对方的端口和对方进行测试通信了。

linux下socket 网络编程(客户端向服务器端发送文件) 求源代码 大哥大姐帮帮忙 。。谢谢

server:

#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 1024

#define SERVPORT 19999

#define BACKLOG 10

int SendFileToServ(const char *path, const char *FileName, const char *ip)

{

#define PORT 20002

int sockfd;

int recvbytes;

char buf[MAXDATASIZE];

char send_str[MAXDATASIZE];

char filepath[128] = {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[16] = {0};

char FileName[128] = {0};

char path[128] = {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", 15);

else if(2 == nret)

write(client_fd, "reload nginx error", 18);

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 1024

#define SERVPORT 20002

#define BACKLOG 10

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);

}

}

以前写的：内容忘记了。不是很复杂你可以自己看！

关于sockettool源代码和sockettool下载的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。