socket.c

linux/unix下c/s形式的资源监视,客户端负责搜集机器,再传送到服务端.

/*
 *  Monitor-Server/socket.c
 *
 *  Copyright (C) 2004 Jian Shen <[e-mail]>
 */

#include "socket.h"
#include "config.h"

#include <linux/net.h>
#include <linux/socket.h>
#include <linux/inet.h>
#include <net/sock.h>
#include <asm/uaccess.h>

int ps_send(struct socket* sock, void* addr, size_t size)
{
	struct msghdr msg;
	mm_segment_t oldfs;
	int error;

	struct iovec msgdata;
	msgdata.iov_base = addr;
	msgdata.iov_len = size;

	/* make up message */
	msg.msg_name     = 0;
	msg.msg_namelen  = 0;
	msg.msg_iov	 = &msgdata;
	msg.msg_iovlen   = 1;
	msg.msg_control  = NULL;
	msg.msg_controllen = 0;
	msg.msg_flags    = 0;  /* Synchronous for now */

	oldfs = get_fs();
	set_fs(KERNEL_DS);
	error = sock_sendmsg(sock, &msg, size);
	set_fs(oldfs);

	return error;
}

int ps_recv(struct socket* sock, void* addr, size_t size)
{
	struct msghdr msg;
	mm_segment_t oldfs;
	int error;

	struct iovec msgdata;
	msgdata.iov_base = addr;
	msgdata.iov_len = size;

	/* make up message */
	msg.msg_name     = 0;
	msg.msg_namelen  = 0;
	msg.msg_iov	 = &msgdata;
	msg.msg_iovlen   = 1;
	msg.msg_control  = NULL;
	msg.msg_controllen = 0;
	msg.msg_flags    = 0;  /* Synchronous for now */

	oldfs = get_fs();
	set_fs(KERNEL_DS);
	error = sock_recvmsg(sock, &msg, size, 0);
	set_fs(oldfs);

	return error;
}

int ps_xread(struct socket* sock, void *buf, size_t len)
{
	char *p = (char *)buf;
	size_t nrecv = 0;
	ssize_t rv;
	
	while (nrecv < len) {
		rv = ps_recv(sock, p, len - nrecv);

		if (rv < 0 && rv == -EINTR)
			continue;
		if (rv < 0)
			return -1;
		if (rv == 0)
			return nrecv;		/* remote close the socket */
		nrecv += rv;
		p += rv;
	}
	return nrecv;
}

#define MAX_SOCK_ADDR   128

int ps_recvfrom(struct socket* sock, void* addr, size_t size, unsigned flags, 
				struct sockaddr_in *ipaddr, int *addr_len)
{
	struct msghdr msg;
	char address[MAX_SOCK_ADDR];
	mm_segment_t oldfs;
	int error;

	struct iovec msgdata;
	msgdata.iov_base = addr;
	msgdata.iov_len = size;

	/* make up message */
	msg.msg_name     = address;
	msg.msg_namelen  = MAX_SOCK_ADDR;
	msg.msg_iov	 = &msgdata;
	msg.msg_iovlen   = 1;
	msg.msg_control  = NULL;
	msg.msg_controllen = 0;
	msg.msg_flags    = 0;  /* Synchronous for now */
/* 	if (sock->file->f_flags & O_NONBLOCK) */
/* 		flags |= MSG_DONTWAIT; */

	oldfs = get_fs();
	set_fs(KERNEL_DS);
	error = sock_recvmsg(sock, &msg, size, flags);
	set_fs(oldfs);

	memcpy(ipaddr, address, msg.msg_namelen);
	*addr_len = msg.msg_namelen;

	return error;
}

int ps_get_proc_list(const char* addr, proc_list_t* plist)
{
	struct socket *sock;
	struct sockaddr_in sin;
	struct sockaddr *saddr;
	int error;

	struct load_request req;
	int rv;

	/* create a socket */
#ifdef KERNEL_2_4
	error = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
#else
	error = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock, 1);
#endif
	if(error < 0) {
	     printk(KERN_ERR "sock_create failed.\n");
		 return -1;
	}

	/* make up address */
	sin.sin_family	     = AF_INET;
	sin.sin_addr.s_addr  = (__u32)in_aton(addr);
	sin.sin_port         = htons((unsigned short)MONPORT);
	memset(&(sin.sin_zero), '\0', 8);

	saddr = (struct sockaddr *)&sin;
	error = sock->ops->connect(sock, saddr, sizeof(struct sockaddr), 0);
	if(error < 0) {
		printk(KERN_ERR "Error connect : %d.\n", -error);
		goto err;
	}

	req.type = PROCLIST;

	rv = ps_send(sock, &req, sizeof(struct load_request));
	if(rv < 0) {
		printk(KERN_ERR "Error sendmsg : %d.\n", -rv);
		goto err;
	}

	rv = ps_xread(sock, plist, sizeof(proc_list_t));

	if(rv < 0) {
		printk(KERN_ERR "Error sendmsg : %d.\n", -rv);
		goto err;
	}

	sock_release(sock);
	return 0;

  err:
	sock_release(sock);
	return -1;
}