如何用编写程序同意接入网络

‘壹’ 用c++编写支持网络功能的程序

封装了如下SOCKET函数，其实使用也挺简单的：

1。客户端函数：
#include<stdlib.h>
#include<winsock.h>
#include<stdio.h>
#include<string.h>

#ifndef INADDR_NONE
#define INADDR_NONE 0xffffffff
#endif

//******************************************************
//
//本函数负责与服务平台联系
//
//******************************************************

SOCKET SocketConnect(const char *host,const char *service,const char *transport)
{
struct protoent *protoin;//传输协议信息
struct sockaddr_in ipaddr;//主机的IP地址信息
struct hostent *hostin;//主机的信息
struct servent *servin;//服务器（主机）信息
int sock,type;//套接字描述符

//将ipaddr结构快速清零
memset(&ipaddr,0,sizeof(ipaddr));
//地址结构
ipaddr.sin_family=AF_INET;

//从服务器类型得到端口号
if(servin=getservbyname(service,transport))
ipaddr.sin_port=servin->s_port;//端口号
else
if((ipaddr.sin_port=htons((u_short)atoi(service)))==0)
{
printf("get server information error/n");
WSACleanup();
return INVALID_SOCKET;
}
//由传输协议得到对应的传输协议编码
if((protoin=getprotobyname(transport))==0)
{
printf("get protocol information error/n");
WSACleanup();
return INVALID_SOCKET;
}
//从主机名获取主机IP
if(hostin=gethostbyname(host))
memcpy(&ipaddr.sin_addr,hostin->h_addr,hostin->h_length);////
else
if((ipaddr.sin_addr.s_addr=inet_addr(host))==INADDR_NONE)
{
printf("get host IP infomation error/n");
WSACleanup();
return INVALID_SOCKET;
}
//根据传输类型给变量赋值
if(strcmp(transport,"udp")==0)
type=SOCK_DGRAM;
else
type=SOCK_STREAM;
//创建套接字描述符
sock=socket(PF_INET,type,protoin->p_proto);
if(sock==INVALID_SOCKET)
{
printf("creat socket error/n");
WSACleanup();
return INVALID_SOCKET;
}

//连接指定IP地址机器的指定服务端口，如果连接失败，则退出
if(connect(sock,(struct sockaddr*)&ipaddr,sizeof(ipaddr))==SOCKET_ERROR)
{
printf("connect socket error!please start server first/n");
WSACleanup();
return INVALID_SOCKET;
}
return sock;
}

//************************************
//UDP传输类型
//************************************
SOCKET UDPConnect(const char *host,const char *service)
{
return SocketConnect(host,service,"udp");
}

//************************************
//TCP传输类型
//************************************
SOCKET TCPConnect(const char *host,const char *service)
{
return SocketConnect(host,service,"tcp");
}

2。客户端函数调用例子(TCP)：
//启动程序后即连接服务器，连接成功后接收控制台输入，发送到服务端
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<winsock.h>
#pragma comment(lib,"wsock32")

#ifndef INADDR_NONE
#define INADDR_NONE 0xffffffff
#endif

SOCKET TCPConnect(const char*,const char*);
void TCPecho(char *,char*);

#define LINELEN 128
#define WAVERS MAKEWORD(2,0)//WORD MAKEWORD(byte bLow,byte bHigh);

void main(int argc,char *argv[])
{
char *host="localhost";//IP 地址
char *service="3333";//默认端口号
WSADATA wsadata;
switch(argc)
{
case 1:
host="localhost";//使用默认IP
break;
case 2:
host=argv[1];//使用命令行给的IP
break;
case 3:
host=argv[1];
service=argv[2];//使用命令行IP和端口号
break;
default:
printf("argment error/n");
exit(1);
}

if(WSAStartup(WAVERS,&wsadata)!=0)//初始化Winsock
{
printf("initalize failed/n");
WSACleanup();//清除Winsock
exit(1);
}

TCPecho(host,service);

WSACleanup();

exit(0);
}

void TCPecho(char *host,char *service)
{
char buf[LINELEN+1];
SOCKET s;
int outchars;

s=TCPConnect(host,service);//采用TCP协议连接服务程序
while(fgets(buf,sizeof(buf),stdin))//循环调用得到用户输入,当输入的数据为回车时退出
{
buf[LINELEN]='/0';
outchars=strlen(buf);
send(s,buf,outchars,0);//发送消息

if(buf[0]=='/n')
break;
}
closesocket(s);
}

3。服务端函数：
#include<string.h>
#include<winsock.h>
#include<stdlib.h>
#include<stdio.h>
//
//SocketServer
//
SOCKET SocketServer(const char *service,const char*transport,int qlen)
{
struct sockaddr_in ipaddr;//主机IP地址
struct servent *servin;// 主机信息
struct protoent *protoin;//传输类型
int sock,type;// 套接字描述符

memset(&ipaddr,0,sizeof(ipaddr));
ipaddr.sin_family=AF_INET;
ipaddr.sin_addr.s_addr=INADDR_ANY;

// 从服务器名得到服务端口
if(servin=getservbyname(service,transport))
ipaddr.sin_port=htons(ntohs((u_short)servin->s_port));
else
if((ipaddr.sin_port=htons((u_short)atoi(service)))==0)
{
printf("get portnumber error/n");
WSACleanup();
return INVALID_SOCKET;
}
//从传输协议得到对应的编号
if((protoin=getprotobyname(transport))==0)
{
printf("get protocol number error/n");
WSACleanup();
return INVALID_SOCKET;
}
//根据传输协议给对应的变量赋值
if(strcmp(transport,"udp")==0)
type=SOCK_DGRAM;
else
type=SOCK_STREAM;
//创建套接字
sock=socket(PF_INET,type,protoin->p_proto);
if(sock==INVALID_SOCKET)
{
printf("creat socket error/n");
WSACleanup();
return INVALID_SOCKET;
}
//绑定本地IP
if(bind(sock,(struct sockaddr*)&ipaddr,sizeof(ipaddr))==SOCKET_ERROR)
{
printf("socket bind error/n");
WSACleanup();
return SOCKET_ERROR;
}
//如果是流式传输（TCP）使套接字处于监听状态，等待来自客户机的连接，参数qlen之指定等待
//队列长度
if(type==SOCK_STREAM)
{
if(listen(sock,qlen)==SOCKET_ERROR)
{
printf("socket listen errror/n");
WSACleanup();
return SOCKET_ERROR;
}
}
return sock;
}

//************************************
//UDPServer
//************************************
SOCKET UDPServer(const char *service)
{
return SocketServer(service,"udp",0);
}

//************************************
//TCPServer
//************************************
SOCKET TCPServer(const char *service,int qlen)
{
return SocketServer(service,"tcp",qlen);
}

4。服务器例子(TCP)：
//接受客户端连接，每接收到客户端发送而来的数据则打印在控制台
#include<winsock.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#pragma comment(lib,"wsock32")

#define QLEN 5
#define BUFSIZE 5
#define WAVERS MAKEWORD(2,0)//WORD MAKEWORD(byte bLow,byte bHigh);

SOCKET TCPServer(const char*service,int qlen);
void main(int argc,char*argv[])
{
char *service="3333";//默认端口号
struct sockaddr_in fsin;
SOCKET msock,ssock;
WSADATA wsadata;
int alen,cc;
char buf[BUFSIZE];

switch(argc)
{
case 1:
break;//采用默认端口号
case 2:
service=argv[1];//采用命令行端口号
break;
default:
printf("argment error/n");
exit(1);
}
if(WSAStartup(WAVERS,&wsadata)!=0)//初始化Winsock
{
printf("initalize failed/n");
WSACleanup();//清除Winsock
exit(1);
}

msock=TCPServer(service,QLEN);//采用TCP协议

while(1)
{
alen=sizeof(struct sockaddr);
ssock=accept(msock,(struct sockaddr*)&fsin,&alen);//accept阻塞接收客户端请求

if(ssock==INVALID_SOCKET)
{
printf("initialize failed/n");
WSACleanup();
exit(1);
}
while(cc=recv(ssock,buf,sizeof(buf)-1,0))//接收客户端信息，当收到的信息为零时，则退出
{
buf[cc]='/0';
printf("%s",buf);
}
printf("connect close...");
closesocket(ssock);
break;
}
}

以上是两个完整的客户端和服务端程序，可建立两个VC控制台工程编译运行，进行连接测试。

‘贰’ 怎么指定某程序使用某个网络呢

用的是无线接入方式上网，可以这样办：法1.有无线网卡的客户机，通通用原始提供的无线方式上网，其他有线的客户机可以看看提供无线的地方能不能拉一根线出来，然后你再在底下接路由器或交换机，让这些客户接到设备上来上网。
法2.要是法1中，不能拉线，必须要一台主机做代理服务器，让有线客户机上网。那台服务器要有一个无线网卡和一个有线网卡，无线网卡连到无线热点；有线网卡可以接一个路由器或交换机，提供有线客户机上网。再把无线连接和有线连接桥接起来就可以了。我觉得只有这样做比较实在点了。无线路由器由于不能用来当无线网卡使，不能让它去查找无线热点，故有线客户机不能用它来代理上网

‘叁’ 如何在系统中设置允许程序访问网络

程序支持联网但连不上的话，退出该软件，在选项里找到许可或者接入这个操作，(打开后因手机而异)，但都有网络许可设置，把不可访问都改为可访问

‘肆’ 如何使用JAVA编写网络通信程序

使用JAVA来进行网络编程
1)
由于客户端通过IE同服务器建立联系，所以客户端使用Applet，服务器端使用Application；
2)
服务器应设置成多线程，应答多个客户的请求；
3)
两端通信使用SOCKET机制。
2.2客户机/服务器通信的动机
客户机-服务器范例的基本动机来自聚集问题。
为了理解这一问题，设想一个人试图在分离的机器上启动两个程序并让它们进行通
信，还要记住，计算机的运行要比人的速度快许多数量级。在某人启动第一个程序后，
该程序开始执行并向其对等程序发送消息，在几个微妙内，它便发现对等程序还不存在，
于是就发出一条错误消息，然后退出。在这时，某个人启动了第二个程序，不幸的是，当第二个程序开始执行时，它发现对等程序已经终止执行了，即便是两个程序连续重新试着通信，
但由于它们每个程序执行的速度那么快。因而它们
在同一瞬间向对方发送消息的概率是很低的。
客户机-服务器模型是这样解决这种聚集问题的。它要求在任何一对进行通信的应用进程中，有一方必须在启动执行后（无限期地）等待对方的联系，这种解决方案是重要的，因为TCP/IP自己对入呼叫通信是不会响应的。
由于TCP/IP并不是提供在一个报文到达后自动创建运行程序的任何机制，因此一个程序必须在任一请求到来前就在那里等待以接受通信。
因此，为确保计算机已准备好了进行通信，多数系统管理员都安排通信程序在操作系统引导时就自动启动。每个程序都一直运行下去，以便等待下一个服务请求的到来（此服务是该程序提供的）
望采纳！！！

‘伍’ android平台wifi的校园网的接入，如何实现，请各位大侠指教，有例子程序或者软件更好，不甚感激

我没有太明白你的意思，是你要搭建校园网的wifi平台，还是学校有wifi平台你先用手机或电脑接入上校园网。
一、如果你要搭建wifi校园网，那需要无线路由设备，构建出校园无线网络。
二、如果是校园有wifi网络了，你先通过手机wifi，或是电脑wifi等移动设备接入的话，那直接打开移动设备网络设置打开wifi搜寻，搜索到校园wifi网络的话直接接入即可。一般无线网络都会设有接入用户名和密码，你需要知道校园网的wifi用户名和密码。这样就可以接入了。

‘陆’ 控制台程序如何进行网络编程

-- win API socket
本文所谈到的Socket函数如果没有特别说明，都是指的Windows Socket API。

一、WSAStartup函数
int WSAStartup(
WORD wVersionRequested,
LPWSADATA lpWSAData
);
使用Socket的程序在使用Socket之前必须调用WSAStartup函数。该函数的第一个参数指明程序请求使用的Socket版本，其中高位字节指明副版本、低位字节指明主版本；操作系统利用第二个参数返回请求的Socket的版本信息。当一个应用程序调用WSAStartup函数时，操作系统根据请求的Socket版本来搜索相应的Socket库，然后绑定找到的Socket库到该应用程序中。以后应用程序就可以调用所请求的Socket库中的其它Socket函数了。该函数执行成功后返回0。
例：假如一个程序要使用2.1版本的Socket,那么程序代码如下
wVersionRequested = MAKEWORD( 2, 1 );
err = WSAStartup( wVersionRequested, &wsaData );

二、WSACleanup函数
int WSACleanup (void);
应用程序在完成对请求的Socket库的使用后，要调用WSACleanup函数来解除与Socket库的绑定并且释放Socket库所占用的系统资源。

三、socket函数
SOCKET socket(
int af,
int type,
int protocol
);
应用程序调用socket函数来创建一个能够进行网络通信的套接字。第一个参数指定应用程序使用的通信协议的协议族，对于TCP/IP协议族，该参数置PF_INET;第二个参数指定要创建的套接字类型，流套接字类型为SOCK_STREAM、数据报套接字类型为SOCK_DGRAM；第三个参数指定应用程序所使用的通信协议。该函数如果调用成功就返回新创建的套接字的描述符，如果失败就返回INVALID_SOCKET。套接字描述符是一个整数类型的值。每个进程的进程空间里都有一个套接字描述符表，该表中存放着套接字描述符和套接字数据结构的对应关系。该表中有一个字段存放新创建的套接字的描述符，另一个字段存放套接字数据结构的地址，因此根据套接字描述符就可以找到其对应的套接字数据结构。每个进程在自己的进程空间里都有一个套接字描述符表但是套接字数据结构都是在操作系统的内核缓冲里。下面是一个创建流套接字的例子：
struct protoent *ppe;
ppe=getprotobyname("tcp");
SOCKET ListenSocket=socket(PF_INET,SOCK_STREAM,ppe->p_proto);

四、closesocket函数
int closesocket(
SOCKET s
);
closesocket函数用来关闭一个描述符为s套接字。由于每个进程中都有一个套接字描述符表，表中的每个套接字描述符都对应了一个位于操作系统缓冲区中的套接字数据结构，因此有可能有几个套接字描述符指向同一个套接字数据结构。套接字数据结构中专门有一个字段存放该结构的被引用次数，即有多少个套接字描述符指向该结构。当调用closesocket函数时，操作系统先检查套接字数据结构中的该字段的值，如果为1，就表明只有一个套接字描述符指向它，因此操作系统就先把s在套接字描述符表中对应的那条表项清除，并且释放s对应的套接字数据结构；如果该字段大于1，那么操作系统仅仅清除s在套接字描述符表中的对应表项，并且把s对应的套接字数据结构的引用次数减1。
closesocket函数如果执行成功就返回0，否则返回SOCKET_ERROR。

五、send函数
int send(
SOCKET s,
const char FAR *buf,
int len,
int flags
);
不论是客户还是服务器应用程序都用send函数来向TCP连接的另一端发送数据。客户程序一般用send函数向服务器发送请求，而服务器则通常用send函数来向客户程序发送应答。该函数的第一个参数指定发送端套接字描述符；第二个参数指明一个存放应用程序要发送数据的缓冲区；第三个参数指明实际要发送的数据的字节数；第四个参数一般置0。这里只描述同步Socket的send函数的执行流程。当调用该函数时，send先比较待发送数据的长度len和套接字s的发送缓冲区的长度，如果len大于s的发送缓冲区的长度，该函数返回SOCKET_ERROR；如果len小于或者等于s的发送缓冲区的长度，那么send先检查协议是否正在发送s的发送缓冲中的数据，如果是就等待协议把数据发送完，如果协议还没有开始发送s的发送缓冲中的数据或者s的发送缓冲中没有数据，那么send就比较s的发送缓冲区的剩余空间和len，如果len大于剩余空间大小send就一直等待协议把s的发送缓冲中的数据发送完，如果len小于剩余空间大小send就仅仅把buf中的数据到剩余空间里（注意并不是send把s的发送缓冲中的数据传到连接的另一端的，而是协议传的，send仅仅是把buf中的数据到s的发送缓冲区的剩余空间里）。如果send函数数据成功，就返回实际的字节数，如果send在数据时出现错误，那么send就返回SOCKET_ERROR；如果send在等待协议传送数据时网络断开的话，那么send函数也返回SOCKET_ERROR。要注意send函数把buf中的数据成功到s的发送缓冲的剩余空间里后它就返回了，但是此时这些数据并不一定马上被传到连接的另一端。如果协议在后续的传送过程中出现网络错误的话，那么下一个Socket函数就会返回SOCKET_ERROR。（每一个除send外的Socket函数在执行的最开始总要先等待套接字的发送缓冲中的数据被协议传送完毕才能继续，如果在等待时出现网络错误，那么该Socket函数就返回SOCKET_ERROR）
注意：在Unix系统下，如果send在等待协议传送数据时网络断开的话，调用send的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

六、recv函数
int recv(
SOCKET s,
char FAR *buf,
int len,
int flags
);
不论是客户还是服务器应用程序都用recv函数从TCP连接的另一端接收数据。该函数的第一个参数指定接收端套接字描述符；第二个参数指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据；第三个参数指明buf的长度；第四个参数一般置0。这里只描述同步Socket的recv函数的执行流程。当应用程序调用recv函数时，recv先等待s的发送缓冲中的数据被协议传送完毕，如果协议在传送s的发送缓冲中的数据时出现网络错误，那么recv函数返回SOCKET_ERROR，如果s的发送缓冲中没有数据或者数据被协议成功发送完毕后，recv先检查套接字s的接收缓冲区，如果s接收缓冲区中没有数据或者协议正在接收数据，那么recv就一直等待，只到协议把数据接收完毕。当协议把数据接收完毕，recv函数就把s的接收缓冲中的数据到buf中（注意协议接收到的数据可能大于buf的长度，所以在这种情况下要调用几次recv函数才能把s的接收缓冲中的数据完。recv函数仅仅是数据，真正的接收数据是协议来完成的），recv函数返回其实际的字节数。如果recv在时出错，那么它返回SOCKET_ERROR；如果recv函数在等待协议接收数据时网络中断了，那么它返回0。
注意：在Unix系统下，如果recv函数在等待协议接收数据时网络断开了，那么调用recv的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

七、bind函数
int bind(
SOCKET s,
const struct sockaddr FAR *name,
int namelen
);
当创建了一个Socket以后，套接字数据结构中有一个默认的IP地址和默认的端口号。一个服务程序必须调用bind函数来给其绑定一个IP地址和一个特定的端口号。客户程序一般不必调用bind函数来为其Socket绑定IP地址和断口号。该函数的第一个参数指定待绑定的Socket描述符；第二个参数指定一个sockaddr结构，该结构是这样定义的：
struct sockaddr {
u_short sa_family;
char sa_data[14];
};
sa_family指定地址族，对于TCP/IP协议族的套接字，给其置AF_INET。当对TCP/IP协议族的套接字进行绑定时，我们通常使用另一个地址结构：
struct sockaddr_in {
short sin_family;
u_short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
};
其中sin_family置AF_INET；sin_port指明端口号；sin_addr结构体中只有一个唯一的字段s_addr，表示IP地址，该字段是一个整数，一般用函数inet_addr（）把字符串形式的IP地址转换成unsigned long型的整数值后再置给s_addr。有的服务器是多宿主机，至少有两个网卡，那么运行在这样的服务器上的服务程序在为其Socket绑定IP地址时可以把htonl(INADDR_ANY)置给s_addr，这样做的好处是不论哪个网段上的客户程序都能与该服务程序通信；如果只给运行在多宿主机上的服务程序的Socket绑定一个固定的IP地址，那么就只有与该IP地址处于同一个网段上的客户程序才能与该服务程序通信。我们用0来填充sin_zero数组，目的是让sockaddr_in结构的大小与sockaddr结构的大小一致。下面是一个bind函数调用的例子：
struct sockaddr_in saddr；
saddr.sin_family = AF_INET;
saddr.sin_port = htons(8888);
saddr.sin_addr.s_addr = htonl(INADDR_ANY);
bind(ListenSocket,(struct sockaddr *)&saddr,sizeof(saddr))；

八、listen函数
int listen( SOCKET s, int backlog );
服务程序可以调用listen函数使其流套接字s处于监听状态。处于监听状态的流套接字s将维护一个客户连接请求队列，该队列最多容纳backlog个客户连接请求。假如该函数执行成功，则返回0；如果执行失败，则返回SOCKET_ERROR。

九、accept函数
SOCKET accept(
SOCKET s,
struct sockaddr FAR *addr,
int FAR *addrlen
);
服务程序调用accept函数从处于监听状态的流套接字s的客户连接请求队列中取出排在最前的一个客户请求，并且创建一个新的套接字来与客户套接字创建连接通道，如果连接成功，就返回新创建的套接字的描述符，以后与客户套接字交换数据的是新创建的套接字；如果失败就返回INVALID_SOCKET。该函数的第一个参数指定处于监听状态的流套接字；操作系统利用第二个参数来返回新创建的套接字的地址结构；操作系统利用第三个参数来返回新创建的套接字的地址结构的长度。下面是一个调用accept的例子：
struct sockaddr_in ServerSocketAddr;
int addrlen;
addrlen=sizeof(ServerSocketAddr);
ServerSocket=accept(ListenSocket,(struct sockaddr *)&ServerSocketAddr,&addrlen);

十、connect函数
int connect(
SOCKET s,
const struct sockaddr FAR *name,
int namelen
);
客户程序调用connect函数来使客户Socket s与监听于name所指定的计算机的特定端口上的服务Socket进行连接。如果连接成功，connect返回0；如果失败则返回SOCKET_ERROR。下面是一个例子：
struct sockaddr_in daddr;
memset((void *)&daddr,0,sizeof(daddr));
daddr.sin_family=AF_INET;
daddr.sin_port=htons(8888);
daddr.sin_addr.s_addr=inet_addr("133.197.22.4");
connect(ClientSocket,(struct sockaddr *)&daddr,sizeof(daddr))；

‘柒’ 如何用C语言编写一个程序实现启用承载网络

#include <windows.h>
#pragma comment(lib, "kernel32.lib")
#pragma comment(lib, "user32.lib")
#pragma comment(linker, "/entry:mainEntry /subsystem:windows")
void mainEntry()
{
wchar_t cmdLine[] = L"netsh.exe wlan start hostednetwork";
STARTUPINFOW si;
PROCESS_INFORMATION pi;

ZeroMemory(&si, sizeof si);
si.cb = sizeof si;

if (CreateProcessW(NULL, cmdLine, 0, 0, FALSE, CREATE_NO_WINDOW, 0, 0, &si, &pi) != FALSE) {
DWORD ret;
WaitForSingleObject(pi.hProcess, INFINITE);
GetExitCodeProcess(pi.hProcess, &ret);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);

if (ret == 0) {
MessageBoxW(NULL, L"成功启用承载网络", L"信息", MB_OK | MB_ICONINFORMATION);
ExitProcess(0);
} else {
MessageBoxW(NULL, L"启用承载网络失败", L"错误", MB_OK | MB_ICONERROR);
ExitProcess(1);
}
} else {
MessageBoxW(NULL, L"执行命令失败", L"错误", MB_OK | MB_ICONERROR);
ExitProcess(2);
}
}

我觉得我简直蛋疼欲裂……