哈尔滨理工大学《UNIX程序设计》
课程设计报告
题目:单消息队列完成客户/服务器进程之间的双向通信院系:计算机科学与技术学院网络工程系
班级学号:
姓名:
指导教师:郭锦兰
成绩:
2013年12月23日
第1章绪论 ..................................................................................................- 1 -
1.1 选题内容 .........................................................................................- 1 -
1.2 相关技术 .........................................................................................- 1 - 第2章系统设计 ..........................................................................................- 1 -
2.1系统介绍 .........................................................................................- 2 -
2.2实现原理 ..........................................................................................- 3 -
2.3主要问题的解决方法及关键技术 (5)
2.4 流程图 (6)
第3章系统实现 (7)
3.1客户端截图 (7)
3.2服务器端截图 (8)
结论 (9)
附录 (10)
附录A 核心程序代码 (10)
绪论
1.1选题内容
单消息队列完成客户/服务器进程之间的双向通信
1.2相关技术
随着对通信双方安全性的要求越来越高,对能使通信安全的机制需求更加迫切,UNIX下在消息队列中嵌入加密解密算法无疑适应了潮流。UNIX为进程提供了丰富的交流方式,其中公开的交流方式有信号量、消息队列、共享内存,有名管道和文件等。采用消息队列作为通信渠道可以弥补这些缺陷:
1.消息队列是一种FIFO的队列性结构,可以保证先送的数据先到达,后
送的数据后到达,避免的插队现象。
2.消息队列将输出的信息进行了打包处理,这样就可以保证以每个消息
为单位进行接收了。
3.消息队列还可以对数据分类,更可以对不同分类的数据采取不同的方
式操作,这更加灵活,安全性更高。
所以,利用消息队列实现客户服务器之间的加密通信是一种很安全的方式,研究单消息队列完成客户服务器之间的加密通信业显得很迫切和必要。
系统设计
2.1系统介绍
本单消息队列完成客户/服务器之间的双向通信是基于消息队列的客户/服务器的通信,对通信数据信息进行有效的加密解密,实现客户/服务器之间的双向安全通信。根据需求分析,将整个系统模块化,分为客户端和服务器端两大部分:客户端将数据加密并传输到服务端;服务器端接受数据并解密输出。
2.2 流程图如下:
2.3实现原理
1. 建立或返回消息队列描述符
进程可用系统调用msgget来建立或返回消息队列的描述符。该系统调用的语法格式为:
int msgget(key,msgflg)
key_t key;
int msgflg;
其中,key是消息队列的名字;msgflg是用户设置的标志。如果IPC_CREAT 表示系统无以key命名的消息队列,则建立消息队列标识符;若已存在,则返回消息队列描述符msgid。
对于系统调用,核心将搜索消息队列头标数组,确定是否有指定关键字的消息队列。若无,核心将分配一新的队列结构,并返回给用户一个消息队列描述符;否则,它只是检查消息队列的许可权之后便返回。
2.消息的发送
进程可用megsnd( )系统调用来发送一个消息,并将它链入消息队列的尾部。该系统调用的语法格式如下:
int msgsnd(msgid,msgp,msgsz,msgflg)
int msgid;
struct msgbuf * msgp;
int msgsz,msgflg;
其中,msgid是由msgget返回的消息队列描述符;msgp指向包含这条消息的结构,该结构由如下两个成员组成:
struct msgbuf
{
long mtype; /* 消息类型 */
char mtext[ ]; /* 消息的文本 */
}
msgsz是mtext的字节长度;msgflg规定了当无内存空间来存储消息时,进程等待还是立即返回。
对于msgsnd( )系统调用,核心检查消息队列描述符和许可权是否合法;
消息长度是否超过系统规定的长度,若过长,进程睡眠等待出现足够大的空间,通过检查后,核心为消息分配消息数据区,并将消息从用户空间拷贝到消息数据区,分配消息首部,将它链入该消息队列的尾部,在消息首部填写消息类型,大小以及指向消息数据区的指针,还有修改消息队列的头标中的数据。然后唤醒在等待消息到来的队列中睡眠的进程。
3. 消息的接收
进程可用msgrcv( )系统调用,从消息队列中读一条消息,语法格式为:int msgrcv(msgid,msgp,msgsz,msgtyp,msgflg)
int msgid,msgsz,msgflg;
struct msgbuf * msgp;
long msgtyp;
其中,msgid,msgp,msgsz,msgflg与msgsnd相似,msgtype是规定用户想读的消息类型。
对于msgrcv( )系统调用是先由核心检查消息队列标识符和许可权,接着根据msgtyp分三种情况处理。
(1) msgtyp=0,核心寻找消息队列中的第一个消息,并将它返回给调用进程;
(2)msgtyp为正整数,核心返回给类型的第一个消息;
(3)msgtyp为负整数,核心应在其类型值小于或等于msgtyp绝对值的所有消息中,选择类型最低的第一消息返回。
如果所返回的消息的大小等于或小于用户请求,核心便将消息正文拷贝到用户区,再从队列中删除该消息,并唤醒睡眠的发送进程;如果消息比用户要求的大,则系统返回错误信息。
4.客户端发送数据的加密
考虑到数据由ASCII码经过编程组成,通过对字符串的每个字符的ASCII 码进行加密便显得基础且高效。因此,对于客户端进程进行加密,服务器端进行解密并回传。加密通过对单个字符的ASCII码操作实现。
5.客户端发送数据的加密
数据加密函数如下:
void encode(char *buf){
long i ;
char buf1[1024];
sscanf(buf,"%s",buf1);
memset(buf,0,sizeof(buf));
for(i = 0;i < strlen(buf1);i++){
sprintf(buf,"%s%03d",buf,buf1[i]+588);
}
}
服务器端接收数据的解密
数据解密函数原型如下:
void decode(char *buf){
int i ,n = strlen(buf);
char buf1[4],data[1024];
memset(data,0,sizeof(data));
for(i = 0 ;i < n;){
memset(buf1,0,sizeof(buf1));
sscanf(buf,"%03s%s",buf1,buf);
i = i+3 ;
sprintf(data,"%s%c",data,atoi(buf1)-588);
}
sprintf(buf,"%s",data);
}
2.4 主要问题的解决方法和关键技术
1.采用面向对象的设计方法:
刚开始课题分析的时候没有将课题分开来分析,费事费力还没有得出好的解决办法。经过思考,采用面向对象的方法,讲各个部分分开来设计,大大减少了工作量,并且在设计时可以专注当前对象,不用顾及其他的模块,只需要提供接口即可。可见,面向对象的设计方法高效。
2.编写加密解密函数的问题:
编写加密解密函数时,我首先上网查了资料,知道了加密有两类,可逆和不可逆,我要用的是可逆性加密。此算法为异或算法,客户端加密,服务器端解密,因为原来对加密解密几乎不了解,从找资料到自己编算法用了不短的时间,从这个过程中,我对加密的重要性有了更深的认识,对加密解密的算法了解了很多,学会了很多。
3.密码学基础知识:
密码学(在西欧语文中,源于希腊语kryptós“隐藏的”,和gráphein “书写”)是研究如何隐密地传递信息的学科。在现代特别指对信息以及其传输的数学性研究,常被认为是数学和计算机科学的分支,和信息论也密切相关。著名的密码学者Ron Rivest解释道:“密码学是关于如何在敌人存在的环境中通讯”,自工程学的角度,这相当于密码学与纯数学的异同。密码学是信息安全等相关议题,如认证、访问控制的核心。密码学的首要目的是隐藏信息的涵义,并不是隐藏信息的存在。密码学也促进了计算机科学,特别是在于电脑与网络安全所使用的技术,如访问控制与信息的机密性。密码学已被应用在日常生活:包括自动柜员机的芯片卡、电脑使用者存取密码、电子商务等等。
密码学
密码学
密码是通信双方按约定的法则进行信息特殊变换的一种重要保密手段。依照这些法则,变明文为密文,称为加密变换;变密文为明文,称为脱密变换。密码在早期仅对文字或数码进行加、脱密变换,随着通信技术的发展,对语音、图像、数据等都可实施加、脱密变换。
数据加密的基本思想是通过变换信息的表示形式来伪装需要保护的敏感信息,使非授权者不能了解被保护信息的内容。网络安全使用密码学来辅助完成在传递敏感信息的的相关问题,主要包括:
(I)机密性(confidentiality)
仅有发送方和指定的接收方能够理解传输的报文内容。窃听者可以截取到加密了的报文,但不能还原出原来的信息,及不能达到报文内容。
(II)鉴别(authentication)
发送方和接收方都应该能证实通信过程所涉及的另一方,通信的另一方确实具有他们所声称的身份。即第三者不能冒充跟你通信的对
方,能对对方的身份进行鉴别。
(III)报文完整性(message intergrity)
即使发送方和接收方可以互相鉴别对方,但他们还需要确保其通信的内容在传输过程中未被改变。
(IV)不可否认性(non-repudiation)
如果人们收到通信对方的报文后,还要证实报文确实来自所宣称的发送方,发送方也不能在发送报文以后否认自己发送过报文
系统实现3.1 客户端截图:
3.2 服务器端截图:
结论
通过这次课程设计,熟悉了UNIX系统下程序开发的流程,对程序设计有了具体的感受和经验。在这次程序设计里面,重点是进程间通讯的加密,通过分析其本质,得到了通过对ASCII码做处理的加密解密方法,大大减少了作业量。可以看出看问题只要抓住实质,解决起来就很快,这也说明了动手之前充分分析的重要性。
在写程序的过程中,通过网络和各个论坛可以找到很多实用的函数原型以及设计思路,这也提醒了我今后开发程序的时候要多吸收优秀的思想和算法,这样才能更快的提高。
这次编程再次体现出了面向对象的程序设计方法的高效,今后的实践中也要坚持这一优秀的思想。
附录
附录A 核心程序代码
一、原程序清单
1.客户端的程序:
#include
#include
#include
#include
void encode(char*);
struct msgbuf{
long type;
char buf[1024];
};
int msgid;
struct msgbuf _msgbuf;
int main(){
if((msgid = msgget(0x1234,0666|IPC_CREAT)) < 0){ fprintf(stderr,"msgget() failed.\n");
return ;
}
_msgbuf.type = getpid() ;
while(1){
fprintf(stderr,"input request :");
scanf("%s",_msgbuf.buf);
if(strcmp(_msgbuf.buf,"exit") == 0 || strcmp(_msgbuf.buf,"quit") == 0){
exit(1);
}
fprintf(stderr,"原码:%s\n",_msgbuf.buf);
encode(_msgbuf.buf);
fprintf(stderr,"加密:%s\n",_msgbuf.buf);
if( msgsnd(msgid,&_msgbuf,strlen(_msgbuf.buf),0) < 0){
fprintf(stderr,"msgsnd() failed.\n");
return ;
}
memset(_msgbuf.buf,0,sizeof(_msgbuf.buf));
if(msgrcv(msgid,&_msgbuf,sizeof(_msgbuf.buf),_msgbuf.type+10000 ,0) < 0){
fprintf(stderr,"msgrcv() failed.\n");
return ;
}
fprintf(stderr,"[%s] receive response .\n",_msgbuf.buf);
}
}
void encode(char *buf){
long i ;
char buf1[1024];
sscanf(buf,"%s",buf1);
memset(buf,0,sizeof(buf));
for(i = 0;i < strlen(buf1);i++){
sprintf(buf,"%s%03d",buf,buf1[i]+588);
}
}
2.服务器端的程序:
#include
#include
#include
#include
struct msgbuf{
long type;
char buf[1024];
};
void decode(char*);
int msgid ;
struct msgbuf _msgbuf;
int main(){
if((msgid = msgget(0x1234,0666|IPC_CREAT)) < 0){ fprintf(stderr,"msgget() failed.\n");
return ;
}
while(1){
bzero(&_msgbuf,sizeof(_msgbuf));
if( msgrcv(msgid,&_msgbuf,sizeof(_msgbuf.buf),0,0) < 0){ fprintf(stderr,"msgrcv() failed.\n");
return ;
}
fprintf(stderr,"原码:%s\n",_msgbuf.buf);
decode(_msgbuf.buf);
fprintf(stderr,"解密:%s\n",_msgbuf.buf);
_msgbuf.type = _msgbuf.type + 10000 ;
if(msgsnd(msgid,&_msgbuf,strlen(_msgbuf.buf),0) < 0){ fprintf(stderr,"msgsnd() failed.\n");
return ;
}
}
}
//解密
void decode(char *buf){
int i ,n = strlen(buf);
char buf1[4],data[1024];
memset(data,0,sizeof(data));
for(i = 0 ;i < n;){
memset(buf1,0,sizeof(buf1));
sscanf(buf,"%03s%s",buf1,buf);
i = i+3 ;
sprintf(data,"%s%c",data,atoi(buf1)-588);
}
sprintf(buf,"%s",data);
}
#include "" #include <> #include
package cn pab import java.util.List; import java.util.Scanner; import cn.pab.dao.PersonDao; import cn.pab.dao.TypeDao; import https://www.doczj.com/doc/4017094229.html,erDao; import cn.pab.dao.impl.PersonDaoImpl; import cn.pab.dao.impl.TypeDaoImpl; import https://www.doczj.com/doc/4017094229.html,erDaoImpl; import cn.pab.entity.Person; import cn.pab.entity.Type; /** * 业务类 */ public class PABmanager { /** * 系统启动 */ public static void main(String[] args) { Scanner input = new Scanner(System.in); UserDao userDao = new UserDaoImpl(); TypeDao typeDao = new TypeDaoImpl(); PersonDao personDao = new PersonDaoImpl(); System.out.println( " System.out.print("\ n 欢迎使用个人通讯录管理系统**********"); 请选择操作(1. 系统登录 2. 密码修改 3. 取消):"); String in = input.next(); if ("1".equals(in)) { boolean islogin = userDao.login(); if(islogin){ System.out.println("******** *** 成功登录个人通讯录管理系统 nm\、\ ? //System.out.print(" \n 退出系统):"); }else{ System.out.println(" System.exit(-1); } }else if ("2".equals(in)) { 请选择操作(1. 类别管理 2. 联系人管理 3. 用户名或密码错误,不能登录!");
客户端与服务器端交互原理 经常看到HTTP客户端与服务器端交互原理的各种版本的文章,但是专业术语太多,且流程过于复杂,不容易消化。于是就按照在Servlet 里面的内容大致做了一些穿插。本来连Tomcat容器和Servlet的生命周期也准备在这里一起写的,但怕过于庞大,于是就简单的引用了一些Servlet对象。这样的一个整个流程看下来,相信至少在理解HTTP协议和request和response是如何完成从请求到生成响应结果回发的。在后续的一些文章里会专门讲一讲Tomcat和Servlet 是如何处理请求和完成响应的,更多的是说明Servlet的生命周期。 HTTP介绍 1. HTTP是一种超文本传送协议(HyperText Transfer Protocol),是一套计算机在网络中通信的一种规则。在TCP/IP体系结构中,HTTP属于应用层协议,位于TCP/IP协议的顶层。 2. HTTP是一种无状态的协议,意思是指在Web浏览器(客户端)和Web 服务器之间不需要建立持久的连接。整个过程就是当一个客户端向服务器端发送一个请求(request),然后Web服务器返回一个响应(respo nse),之后连接就关闭了,在服务端此时是没有保留连接的信息。 3. HTTP遵循请求/响应(request/response)模型的,所有的通信交互都被构造在一套请求和响应模型中。 4. 浏览Web时,浏览器通过HTTP协议与Web服务器交换信息,Web服务器向Web 浏览器返回的文件都有与之相关的类型,这些信息类型的格式由 MIME 定义。 HTTP定义的事务处理由以下四步组成: 1. 建立连接。 2?客户端发送HTTP请求头。 3. 服务器端响应生成结果回发。 4. 服务器端关闭连接,客户端解析回发响应头,恢复页面。
源代码: #include "stdio.h" #include "stdlib.h" #include "string.h" #include "conio.h" #include "stdlib.h" #define null 0 struct record { char name[20]; char phone[20]; char adress[40]; char postcode[10]; char e_mail[30]; }student[500]; struct LinkList { struct record US; struct LinkList *next; }a; struct LinkList *head=null; int num=0; FILE *fp; int menu_select(); int adduser(); int list(); int search(); int display(); int add(); int listbyname(); int dele(); int save(); int exit(); void main() {
system("cls"); for(;;) { switch(menu_select()) { case 0:adduser();break; case 1:list();break; case 2:search();break; case 3:display();break; case 4:add();break; case 5:listbyname();break; case 6:dele();break; case 7:save();break; case 8:exit(0); } } } menu_select() { char s[80]; int a; printf("*_* press any key enter menu! *_* \n"); getch(); system("cls"); printf("\t\t********************MENU*********************\n\n"); printf("\t\t 0. 输入记录\n"); printf("\t\t 1. 显示记录\n"); printf("\t\t 2. 按姓名查找\n"); printf("\t\t 3. 按电话号码查找\n"); printf("\t\t 4. 插入记录\n"); printf("\t\t 5. 按姓名排序\n"); printf("\t\t 6. 删除记录\n"); printf("\t\t 7. 记录保存文件\n"); printf("\t\t 8. Quit\n"); printf("\t\t***********************************************\n"); do{ printf("\n Enter you choice(0~11):"); scanf("%s",s); a=atoi(s); } while (a<0||a>11); return a;
实验六基于TCP/IP的网络编程 1 实验目的 MFC提供的关于网络应用的类CSocket是一个比较高级的封装,使用它编制出属于自己的网络应用程序,可以编一个属于自己的网络通讯软件。通过这个实验,同学们也可以增进对于TCP/IP协议的理解。 2 实验内容 基于TCP/IP的通信基本上都是利用SOCKET套接字进行数据通讯,程序一般分为服务器端和用户端两部分。设计思路(VC6.0下): 第一部分服务器端 一、创建服务器套接字(create)。 二、服务器套接字进行信息绑定(bind),并开始监听连接(listen)。 三、接受来自用户端的连接请求(accept)。 四、开始数据传输(send/receive)。 五、关闭套接字(closesocket)。 第二部分客户端 一、创建客户套接字(create)。 二、与远程服务器进行连接(connect),如被接受则创建接收进程。 三、开始数据传输(send/receive)。 四、关闭套接字(closesocket)。 CSocket的编程步骤:(注意我们一定要在创建MFC程序第二步的时候选上Windows Socket 选项,其中ServerSocket是服务器端用到的,ClientSocket是客户端用的。) (1)构造CSocket对象,如下例: CSocket ServerSocket; CSocket ClientSocket; (2)CSocket对象的Create函数用来创建Windows Socket,Create()函数会自行调用Bind()函数将此Socket绑定到指定的地址上面。如下例: ServerSocket.Create(823); //服务器端需要指定一个端口号,我们用823。ClientSocket.Create(); //客户端不用指定端口号。 (3)现在已经创建完基本的Socket对象了,现在我们来启动它,对于服务器端,我们需要这个Socket不停的监听是否有来自于网络上的连接请求,如下例: ServerSocket.Listen(5);//参数5是表示我们的待处理Socket队列中最多能有几个Socket。(4)对于客户端我们就要实行连接了,具体实现如下例: ClientSocket.Connect(CString SerAddress,Unsinged int SerPort);//其中SerAddress是服务器的IP地址,SerPort是端口号。 (5)服务器是怎么来接受这份连接的呢?它会进一步调用Accept(ReceiveSocket)来接收它,而此时服务器端还须建立一个新的CSocket对象,用它来和客户端进行交流。如下例:CSocket ReceiveSocket; ServerSocket.Accept(ReceiveSocket); (6)如果想在两个程序之间接收或发送信息,MFC也提供了相应的函数。 (7)代码 package test.socket3; import java.awt.event.ActionEvent; import java.awt.event.ActionListener;
计算机操作系统实验第六次实验报告 学院:计算机科学与信息学院专业:通信工程班级:081姓名学号 实验 组 实验时间2010年11月17日指导教师成绩 实验项目名称进程的管道通信实 验目的 1、了解什么是管道; 2、熟悉UNIX/LINUX支持的管道通信方式。 实 验要求 1、了解管道的概念和管道的类型; 2、熟悉UNIX/LINUX支持的管道通信方式。 实 验 原 理 在管道通信时系统会调用:pipe( )建立一无名管道;read( );write( ) 。 实 验 仪 器 PC机或工作站一台; RedHat9.0操作系统;
实验步骤一、什么是管道 UNIX系统在OS的发展上,最重要的贡献之一便是该系统首创了管道(pipe)。这也是UNIX系统的一大特色。 所谓管道,是指能够连接一个写进程和一个读进程的、并允许它们以生产者—消费者方式进行通信的一个共享文件,又称为pipe文件。由写进程从管道的写入端(句柄1)将数据写入管道,而读进程则从管道的读出端(句柄0)读出数据。 句柄fd[0] 句柄fd[1] 读出端 写入端 二、管道的类型: 1、有名管道 一个可以在文件系统中长期存在的、具有路径名的文件。用系统调用mknod( )建立。它克服无名管道使用上的局限性,可让更多的进程也能利用管道进行通信。因而其它进程可以知道它的存在,并能利用路径名来访问该文件。对有名管道的访问方式与访问其他文件一样,需先用open( )打开。 2、无名管道 一个临时文件。利用pipe( )建立起来的无名文件(无路径名)。只用该系统调用所返回的文件描述符来标识该文件,故只有调用pipe( )的进程及其子孙进程才能识别此文件描述符,才能利用该文件(管道)进行通信。当这些进程不再使用此管道时,核心收回其索引结点。 二种管道的读写方式是相同的,本文只讲无名管道。 3、pipe文件的建立 分配磁盘和内存索引结点、为读进程分配文件表项、为写进程分配文件表项、分配用户文件描述符 4、读/写进程互斥 内核为地址设置一个读指针和一个写指针,按先进先出顺序读、写。 为使读、写进程互斥地访问pipe文件,需使各进程互斥地访问pipe文件索引结点中的直接地址项。因此,每次进程在访问pipe文件前,都需检查该索引文件是否已被上锁。若是,进程便睡眠等待,否则,将其上锁,进行读/写。操作结束后解锁,并唤醒因该索引结点上锁而睡眠的进程。 三、所涉及的系统调用 1、pipe( ) 建立一无名管道。 系统调用格式 pipe(filedes) 参数定义 int pipe(filedes); int filedes[2]; 其中,filedes[1]是写入端,filedes[0]是读出端。 该函数使用头文件如下: #include
服务器端界面 服务器端代码: using System; using System.Collections.Generic; using https://www.doczj.com/doc/4017094229.html,ponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using https://www.doczj.com/doc/4017094229.html,.Sockets; using System.Threading; using System.IO; using https://www.doczj.com/doc/4017094229.html,; using System.Collections; namespace IMS.Server { public partial class Server : Form { TcpListener myListener; TcpClient tcpClient = new TcpClient(); Thread mythread; NetworkStream ns;
public Server() { InitializeComponent(); } private void Server_Load(object sender, EventArgs e) { Control.CheckForIllegalCrossThreadCalls = false; mythread = new Thread(new ThreadStart(receive)); mythread.IsBackground = true; mythread.Start(); } private void receive() { myListener = new TcpListener(IPAddress.Parse("192.168.1.106"), 8080); myListener.Start(); tcpClient = myListener.AcceptTcpClient(); while (true) { string rec = ""; ns = tcpClient.GetStream(); byte[] bytes = new byte[1024]; ns.Read(bytes,0,bytes.Length); rec = Encoding.Unicode.GetString(bytes); richTextBox1.Text = rec; ns.Flush(); } } private void btnSend_Click(object sender, EventArgs e) { try { ns = tcpClient.GetStream(); byte[] bytes = new byte[1024]; // bytes = Encoding.Unicode.GetBytes(sendmsg); bytes = Encoding.Unicode.GetBytes(richTextBox1.Text +"\r\n" + "服务器说:" + richTextBox2.Text);
服务器与移动客户端通信设计 软件的通信方式是开发过程中的重要一环。智能手机的快速发展,使得手机不仅作为一般通讯工具,更进一步成为一款便携式移动互联网终端。通常来说,Android操作系统的手机使用Android系统自身集成的HttpClient直接访问网络资源[35]。 服务器MySQL 图4.7 客户端与数据库通信方式示意图 Fig.4.7 Communication mode between client and database HttpClient是一种HTTP协议的支撑工具包,它能够为客户端提供一系列高效、便捷、多功能的编程工具,且能够支持最新的HTTP协议,操作简单。对于HTTP连接中的各种复杂问题都能够予以有效的解决。如上图4.7所示,HttpClient 实现HTTP协议的方法,主要是GET与POST两种方法。 1.GET方法。HTTP协议的GET方法即利用HttpClient向客户端发送GET 请求,这一过程一般用来进行客户端的信息查询操作,例如,在本次客户端中, 其可以用于 检修故障信息、零部件信息以及检修工单信息的查询。具体的实现步骤有以下几 步[36]: 1) 创建HttpClient实例;2) 创建HttpPost实例。 3) 将需要发送的GET请求参数直接连接至URL地址中,并用“?”将参 数与地址隔开,每个参数之间用“&”隔开,若有需要额外添加的参数,可以选 择调用setParams()的方式来进行添加。 4) 调用第一步创建的HttpClient实例中的execute()方法来执行第二步创建 的HttpGet实例,并读取Response对象。 5) 采取调用getAllHeaders()、getHeaders(String name)等方式获取服务器响应,并释放连接,无论上述第四步的执行过程是否成功,都必须释放连接,允许 用户获得服务器的响应内容。 2.POST方法。HTTP协议的POST方法即利用HttpClient向客户端发送POST 请求,该请求过程一般用来进行客户端的信息修改操作,例如,在本课题所设计 的客户端中,其可以用于对登录、密码等修改等操作。其具体的实现过程也分为 五个步骤:
实验4 进程的管道通信 1. 目的 1)加深对进程概念的理解,明确进程和程序的区别。 2)进一步认识并发执行的实质。 3)分析进程争用资源的现象,学习解决进程互斥的方法。 4)学习解决进程同步的方法。 5)了解Linux系统中进程通信的基本原理。 进程是操作系统中最重要的概念,贯穿始终,也是学习现代操作系统的关键。通过本次实验,要求理解进程的实质和进程管理的机制。在Linux系统下实现进程从创建到终止的全过程,从中体会进程的创建过程、父进程和子进程之间的关系、进程状态的变化、进程之间的互斥、同步机制、进程调度的原理和以管道为代表的进程间的通信方式的实现。 2. 内容及要求 这是一个设计型实验,要求自行编制程序。 使用系统调用pipe()建立一条管道,两个子进程分别向管道写一句话: Child process1 is sending a message! Child process2 is sending a message! 父进程从管道读出来自两个子进程的信息,显示在屏幕上。 要求: 1)父进程先接收子进程1发来的消息,然后再接收子进程2发来的消息。 2)实现管道的互斥使用,当一个子进程正在对管道进行写操作时,另一子进程必须等待。使用系统调用lockf(fd[1],1,0)实现对管道的加锁操作,用lockf(fd[1],0,0)解除对 管道的锁定。 3)实现父子进程的同步,当子进程把数据写入管道后,便去睡眠等待;当父进程试图从一空管道中读取数据时,也应等待,直到子进程将数据写入管道后,才将其唤醒。 3.相关的系统调用 1)fork() 用于创建一个子进程。 格式:int fork(); 返回值:在子进程中返回0;在父进程中返回所创建的子进程的ID值;当返回-1时,创建失败。 2)wait() 常用来控制父进程与子进程的同步。 在父进程中调用wait(),则父进程被阻塞,进入等待队列,等待子进程结束。当子进程结束时,父进程从wait()返回继续执行原来的程序。 返回值:大于0时,为子进程的ID值;等于-1时,调用失败。 3)exit() 是进程结束时最常调用的。 格式:void exit( int status); 其中,status为进程结束状态。 4)pipe() 用于创建一个管道 格式:pipe(int fd); 其中fd是一个由两个数组元素fd[0]和fd[1]组成的整型数组,fd[0]是管道的读端口,用
Linux网络编程-基础知识(1) 1. Linux网络知识介绍 1.1 客户端程序和服务端程序 网络程序和普通的程序有一个最大的区别是网络程序是由两个部分组成的--客户端和服务器端. 网络程序是先有服务器程序启动,等待客户端的程序运行并建立连接. 一般的来说是服务端的程序在一个端口上监听,直到有一个客户端的程序发来了请求. 1.2 常用的命令 由于网络程序是有两个部分组成,所以在调试的时候比较麻烦,为此我们有必要知道一些常用的网络命令 netstat 命令netstat是用来显示网络的连接,路由表和接口统计等网络的信息. netstat有许多的选项我们常用的选项是-an 用来显示详细的网络状态.至于其它的选项我们可以使用帮助手册获得详细的情况. telnet telnet是一个用来远程控制的程序,但是我们完全可以用这个程序来调试我们的服务端程序的. 比如我们的服务器程序在监听8888端口,我们可以用telnet localhost 8888来查看服务端的状况. 1.3 TCP/UDP介绍 TCP(Transfer Control Protocol)传输控制协议是一种面向连接的协议, 当我们的网络程序使用这个协议的时候,网络可以保证我们的客户端和服务端的连接是可靠的,安全的. UDP(User Datagram Protocol)用户数据报协议是一种非面向连接的协议, 这种协议并不能保证我们的网络程序的连接是可靠的,所以我们现在编写的程序一般是采用TCP协议的. Linux网络编程-简单的客户端和服务器通讯程序开发入门(2)简介: 本文详细介绍了Linux下B/S结构的客户端服务器通讯程序的开发入门, 其中对重要的网络函数和结构体作了详细的说明和分析, 最后给出一个简单的客户端和服务器通讯程序示例以加深理解。 2. 初等网络函数介绍(TCP) Linux系统是通过提供套接字(socket)来进行网络编程的.网络程序通过socket和其它几个函数的调用, 会返回一个通讯的文件描述符,我们可以将这个描述符看成普通的文件的描述符来操作, 这就是linux的设备无关性的好处.我们可以通过向描述符读写操作实现网络之间的数据交流. 2.1 socket
实验四:进程的管道通信 1.实验目的 1)加深对进程概念的理解,明确进程和程序的区别。 2)学习进程创建的过程,进一步认识进程并发执行的实质。 3)分析进程争用资源的现象,学习解决进程互斥的方法。 4)学习解决进程同步的方法。 5)掌握Linux系统中进程间通过管道通信的具体实现。 2.实验内容 使用系统调用pipe()建立一条管道,系统调用fork()分别创建两个子进程,它们分别向管道写一句话,如: Child process1 is sending a message! Child process2 is sending a message! 父进程分别从管道读出来自两个子进程的信息,显示在屏幕上。 3.实验要求 这是一个设计型实验,要求自行、独立编制程序。 两个子进程要并发执行。 实现管道的互斥使用。当一个子进程正在对管道进行写操作时,另一个欲写入管道的子进程必须等待。 使用系统调用lockf(fd[1],1,0)实现对管道的加锁操作,用lockf(fd[1],0,0)解除对管道的锁定。 实现父子进程的同步,当父进程试图从一空管道中读取数据时,便进入等待状态,直到子进程将数据写入管道返回后,才将其唤醒。 fork() 用于创一个子进程。格式:int fork();返回值:在子进程中返回0;在父进程中返回所创建的子进程的ID值;当返回-1时,创建失败。 wait() 常用来控制父进程与子进程的同步。在父进程中调用wait(),则父进程被阻塞,进入等待队列,等待子进程结束。当子进程结束时,父进程从wait()返回继续执行原来的程序。返回值:大于0时,为子进程的ID值;等于-1时,调用失败。 exit() 是进程结束时最常调用的。格式:void exit( int status); 其中,status为进程结束状态。 pipe() 用于创建一个管道格式:pipe(int fd);其中fd是一个由两个数组元素fd[0]和fd[1]组成的整型数组,fd[0]是管道的读端口,用于从管道读出数据,fd[1]是管道的写端口,用于向管道写入数据。返回值:0 调用成功;-1 调用失败。 sleep() 使调用进程睡眠若干时间,之后唤醒。格式:sleep(int t);其中t为睡眠时间。 lockf() 用于对互斥资源加锁和解锁。在本实验中该调用的格式为: lockf(fd[1],1,0);/* 表示对管道的写入端口加锁。 lockf(fd[1],0,0);/* 表示对管道的写入端口解锁。
SimpleChatServer.java package test.chatclient; import java.io.*; import https://www.doczj.com/doc/4017094229.html,.*; import java.util.*; public class SimpleChatServer { ArrayList
个人通讯录管理系统C语言源程序优秀版 Last revision date: 13 December 2020.
#i n c l u d e/*头文件*/ #include
实验二 进程间通信
一、实验目的 在本实验中,通过对文件映射对象的了解,来加深对 Windows 2000 线程同步的理解. 回顾系统进程、线程的有关概念,加深对 Windows 2000 线程间通讯的理解;了解文件映射 对象;通过分析实验程序,了解线程如何通过文件映射对象发送数据;了解在进程中如何使 用文件映射对象. 二、背景知识 1. 共享内存: Windows 2000 提供了一种在文件中处理数据的方法, 名为内存映射文件, 也称为文件映射.文件映射对象是在虚拟内存中分配的永久或临时文件对象区域 (如果可能 的话,可大到整个文件) ,可将其看作是二进制的数据块.使用这类对象,可获得直接在内 存中访问文件内容的能力. 文件映射对象提供了强大的扫描文件中数据的能力,而不必移动文件指针.对于多线程 的读写操作来说, 这一点特别有用, 因为每个线程都可能想要把读取指针移动到不同的位置 去——为了防止这种情况,就需要使用某种线程同步机制保护文件. 在 CreateFileMapping() API 中,一个新的文件映射对象需要有一个永久的文件对象 (由 CreateFile() 所创建) .该函数使用标准的安全性和命名参数,还有用于允许操作 (如只读) 的保护标志以及映射的最大容量.随后可根据来自 OpenFileMapping() API 的其他线程或进程 使用该映射——这与事件和互斥体的打开进程是非常类似的. 内存映射文件对象的另一个强大的应用是可请求系统创建一个运行映射的临时文件.该 临时文件提供一个临时的区域, 用于线程或进程互相发送大量数据, 而不必创建或保护磁盘 上的文件.利用向创建函数中发送 INVALID_HANDLE_VALUE 来代替真正的文件句柄,就 可创建这一临时的内存映射文件; 指令内核使用系统页式文件来建立支持映射的最大容量的 临时数据区. 为了利用文件映射对象,进程必须将对文件的查看映射到它的内存空间中.也就是说, 应该将文件映射对象想象为进程的第一步,在这一步中,当查看实际上允许访问的数据时, 附加有共享数据的安全性和命名方式.为了获得指向内存区域的指针需要调用 MapViewOfFile() API,此调用使用文件映射对象的句柄作为其主要参数.此外还有所需的访 问等级 (如读-写) 和开始查看时文件内的偏移和要查看的容量.该函数返回一个指向进程内 的内存的指针,此指针可有多种编程方面的应用 (但不能超过访问权限) . 当结束文件映射查看时,必须用接受到的指针调用 UnmapViewOfFlie() API,然后再根 据映射对象调用 CloseHandle() API,从而将其清除。
三、实验内容 1. 编译运行项目 Lab5.1\SHAREMEM.DSW,观察运行结果,并阅读和分析实验程序.
Socket服务器与客户端双向通信实例 using System; using System.Collections.Generic; using https://www.doczj.com/doc/4017094229.html,ponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using https://www.doczj.com/doc/4017094229.html,; using https://www.doczj.com/doc/4017094229.html,.Sockets;//添加命名空间 using System.Threading;//添加命名空间 namespace WFAsynSocket { public partial class Form1 : Form { Thread LisThread;
Socket LisSocket; Socket newSocket; EndPoint point; string strmes = String.Empty; int port = 8000;//定义侦听端口号 public Form1() { InitializeComponent(); } private void btn_Listen_Click(object sender, EventArgs e) { LisThread = new Thread(new ThreadStart(BeginListern));//开线程执行BeginListern方法 LisThread.Start();//线程开始执行 } public IPAddress GetIP() { /*获取本地服务器的ip地址 */ IPHostEntry iep = Dns.GetHostEntry(Dns.GetHostName()); IPAddress ip = iep.AddressList[0]; return ip; } public void BeginListern() { LisSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, Proto colType.Tcp);//实例化Socket IPAddress ServerIp = GetIP();/*获取本地服务器的ip地址 */ IPEndPoint iep = new IPEndPoint(ServerIp, port); LisSocket.Bind(iep); /*将Socket绑定ip */ toolStripStatusLabel1.Text = iep.ToString() + "正在监听"; LisSocket.Listen(50); //Socket开始监听 newSocket = LisSocket.Accept();//获取连接请求的Socket /*接收客户端Socket所发的信息 */ while (true) { try {
2009.17 网络与通信 NETWORK&COMMUNICATION 1引言 大部分网络协议的实现都由客户端(Client)和服务器端 (Server)来协作完成。这种模型本质上涉及两个不同的程序, 通常这两个程序在不同机器上运行。这些机器之间都有网络连接。服务器端程序提供服务并对来自客户程序的请求作成响应。而客户端程序则是在使用者和服务器端程序之间建立某种沟通的渠道,或者是作为使用服务器端提供的某种网络服务的工具。 一个典型的服务器与客户机之间的交互可能如下所示:(1)客户机提出一个请求; (2)服务器收到客户机的请求,进行分析处理;(3)服务器将运行处理的结果返回给客户机。 通常一个服务器需要向多个客户机提供服务。因此对服务器来说,还需要考虑如何有效地处理多个客户的请求。 2服务器与客户端的Socket 通信类型 Socket 的连接类型可以分为两种,分别是面向连接的字节 流类型(Sock_stream)和面向无连接数据报类型(Sock_dgram)。 面向无连接数据报类型的Socket 工作流程比较简单,双方不需要进行太多的沟通与交互。客户机直接将用户的请求打包发送到服务器端,省略了建立一个固定信息通道的过程。服务器端也是直接将处理的结果发送给客户端。其工作流程如图1所示。 面向连接的字节流类型的Socket 工作中有比较严格的操作次序,工作的原理也比较复杂。在这种类型的Socket 的工作过程中,必须首先启动服务器端,通过调用Socket ()函数建立一个Socket 对象,然后调用Bind ()函数将该Socket 对象和本地网络地址绑定到一起,再调用Listen ()函数使该Socket 对象处于侦听状态,并规定它的最大请求的数量。其工作流程如图2所示。 总的来说,无连接和面向连接的通信方式各有长处和短处。在仅仅涉及少量的信息传递的场合可以使用无连接操作;如果涉及大量信息传递的场合可以采用面向连接操作。 3Delphi 的Socket 组件 ClientSocket 组件为客户端组件。它是通信的请求方,也 就是说,它是主动地与服务器端建立连接。 客户端与服务器端的Socket 通信 夏 玲 摘 要:介绍有关Socket 通讯应用的基本知识,并通过客户端和服务器端的Delphi 编程实 例,说明两者是如何进行通信的。 关键词:Socket ;Delphi ;通信;客户端;服务器端 图1 无连接Socket 操作流程 图2 面向连接Socket 操作流程 49