RPGIV编程语言中的网络编程：Sockets教程

需积分: 9 106 浏览量更新于2024-07-05 收藏 496KB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

"RPGIVSocketTutorial by Scott Klement 是一本针对AS/400或iSeries平台上的RPGIV程序员的网络编程教程，重点介绍了使用套接字进行TCP通信的基础知识。教程假设读者已经熟悉RPGIV语言，包括原型、子程序、服务程序和指针的使用。" 在本教程中，作者首先介绍了TCP和套接字的基本概念： 1. **TCP/IP概念和术语**：TCP（传输控制协议）是互联网协议栈中的一个关键组件，负责在两个网络端点之间建立可靠的双向通信。套接字是实现TCP/IP通信的应用程序编程接口（API），它允许程序发送和接收数据。 2. **TCP通信会话概述**：TCP通信通常涉及三个阶段：连接建立（三次握手）、数据传输和连接关闭（四次挥手）。在连接建立后，数据被分片并按顺序发送，以确保数据的完整性和无丢失。接下来，教程探讨了查找主机名和服务的方法： 2.1. **服务和端口**：服务通常与特定的端口号关联，例如HTTP服务默认使用80端口，FTP使用21端口。端口是标识应用程序进程的逻辑地址。 2.2. **主机名和地址**：主机名是人类可读的服务器标识，如www.google.com，而IP地址是数字形式，如192.168.1.1。DNS（域名系统）用于将主机名解析为IP地址。然后，教程逐步解释了创建第一个客户端程序所需的套接字API调用： 3.1. **socket() API调用**：创建一个新的套接字，指定协议族（如AF_INET）和套接字类型（如SOCK_STREAM，对应TCP）。 3.2. **connect() API调用**：连接到远程服务器的指定端口，需要提供服务器的IP地址和端口号。 3.3. **send() 和 recv() API调用**：send()用于发送数据，recv()用于接收数据。这两个函数是TCP通信的核心，确保数据的发送和接收。 3.4. **ASCII到EBCDIC转换**：由于AS/400系统使用EBCDIC编码，而网络通常使用ASCII，因此在发送和接收数据时需要进行字符编码的转换。 3.5. **close() API调用**：关闭已使用的套接字，释放系统资源。最后，教程通过改进客户端程序来提升其功能： 4.1. **使用头文件**：引入头文件以简化代码和提高可读性。 4.2. **错误处理**：添加错误检查代码，确保程序在遇到问题时能够优雅地处理。 4.3. **创建ReadLine工具**：为了更方便地读取用户输入或服务器响应，编写一个读取整行的辅助函数。 4.4. **创建WriteLine工具**：类似地，创建一个写入整行的函数，简化输出操作。这个教程旨在引导RPGIV程序员理解和实现基于TCP的网络通信，通过实例逐步讲解如何创建和管理套接字，以及如何在AS/400系统上进行TCP通信。

资源详情

资源推荐

Chapter 2. Looking up host names & services

D h_addr S 10U 0 Based(p_h_addr)

So, if we want to refer to the ﬁrst IP address listed under h_addr_list, we can now just refer to h_addr. If we need to

deal with later addresses in the list (which is very unusual, in my experiences) we can do so like this:

D addr_list S * DIM(100) Based(h_addr_list)

D p_oneaddr S *

D oneaddr S 10U 0 based(p_oneaddr)

CL0N01Factor1+++++++Opcode&ExtFactor2+++++++Result++++++++Len++D+HiLo

C do 100 x

C if addr_list(X) = *NULL

C leave

C endif

C eval p_oneaddr = addr_list(X)

C*** oneaddr now contains the IP address of this

C*** position of the array, use it now...

C enddo

As I stated, however, it’s very unusual to need to work with anything but the ﬁrst address in the list. Therefore,

’h_addr’ is usually what we’ll refer to when we want to get an IP address using gethostbyname.

And we’d normally call gethostbyname like this:

c eval p_hostent = gethostbyname(’www.ibm.com’)

c if p_hostent <> *NULL

c eval IP = h_addr

c endif

Now that we know the basic syntax to call these APIs, lets put them together and write a program that uses them.

When we write a client program for TCP/IP, usually the ﬁrst thing we need to do is ﬁgure out the IP address to

connect to. Generally, this is supplied by the user, and the user will either supply an IP address directly (in the

dotted-decimal format) or he’ll supply a hostname that needs to be looked up.

The way that we go about doing this is by ﬁrst calling ’inet_addr’ to see if the host is a valid dotted-decimal format

IP address. If it is not, we’ll actually call ’gethostbyname’ to look the address up using DNS and/or the host table. In

our example program, we’ll then either print a ’host not found’ error message, or we’ll call ’inet_ntoa’ to get a

dotted-decimal format IP address that we can print to the screen.

So here’s our example of looking up an IP address for a hostname:

File: SOCKTUT/QRPGLESRC, Member: DNSLOOKUP

H DFTACTGRP(*NO) ACTGRP(*NEW)

D inet_addr PR 10U 0 ExtProc(’inet_addr’)

D address_str * value options(*string)

D INADDR_NONE C CONST(4294967295)

D inet_ntoa PR * ExtProc(’inet_ntoa’)

Chapter 3. Socket API calls to create our ﬁrst

client program

Written by Scott Klement.

3.1. The socket() API call

The previous sections explained how to ﬁnd out the port number for a service name, and how to get the IP address

for a host name. This section will utilize that information to create a simple client program.

The socket() API is used to create a socket. You can think of a socket as being the virtual device that is used to read

& write data from a network connection.

The IBM manual page that documents the socket API is at this link:

http://publib.boulder.ibm.com/pubs/html/as400/v4r5/ic2924/info/apis/socket.htm

It lists the following as the prototype for the socket() API:

int socket(int address_family,

int type,

int protocol)

This tells us that the name of the procedure to call is ’socket’, and that it accepts 3 parameters. Each one is an integer,

passed by value. It also returns an integer. Therefore, the RPG prototype for the socket() API looks like this:

D socket PR 10I 0 ExtProc(’socket’)

D addr_family 10I 0 value

D type 10I 0 value

D protocol 10I 0 value

It’s important to realize that the socket APIs can be used for other networking protocols besides TCP/IP. When we

create a socket, we need to explain to the socket API that we wish to communicate using the IP protocol, and that we

wish to use TCP on top of the IP protocol.

For address family, the manual tells us that we need to specify a value of ’AF_INET’ if we wish to do network

programming in the ’Internet domain’. Therefore, when we specify a value of ’AF_INET’, what we’re really telling

the API is to ’use the IP protocol’.

Under the ’type’ parameter, it allows us to give values of ’SOCK_DGRAM’, ’SOCK_SEQPACKET’,

’SOCK_STREAM’ or ’SOCK_RAW’. The TCP protocol is the standard streaming protocol for use over IP. So, if we

say ’SOCK_STREAM’, we’ll use the TCP protocol. As you might imagine, SOCK_DGRAM is used for the UDP

protocol and SOCK_RAW is used for writing raw IP datagrams.

Finally, we specify which protocol we wish to use with our socket. Note that, again, we can specify IPPROTO_TCP

for TCP, IPPROTO_UDP for UDP, etc. However, this isn’t necessary! Because we already speciﬁed that we wanted a

’stream socket’ over ’internet domain’, it already knows that it should be using TCP. Therefore, we can specify

’IPPROTO_IP’ if we want, and the API will use the default protocol for the socket type.

Chapter 3. Socket API calls to create our ﬁrst client program

Now, we just have one problem: We don’t know what integer values AF_INET, SOCK_STREAM and IPPPROTO_IP

are! IBM is referencing named constants that they’ve deﬁned in the appropriate header ﬁles for C programs, but we

don’t have these deﬁned for us in RPG! But, if you do a bit of snooping into the ’System Openness Includes’ library,

you’ll ﬁnd that AF_INET is deﬁned to be ’2’, SOCK_STREAM is deﬁned to be ’1’, and IPPROTO_IP is deﬁned as

’0’. To make this easier for us, we’ll make named constants that match these values, like so:

D AF_INET C CONST(2)

D SOCK_STREAM C CONST(1)

D IPPROTO_IP C CONST(0)

Now we can call the socket() API like so:

c eval s = socket(AF_INET:SOCK_STREAM:IPPROTO_IP)

3.2. The connect() API call

Once we have a socket to work with, we need to connect it to something. We do that using the connect() API, which

is documented in IBM’s manual at this location:

http://publib.boulder.ibm.com/pubs/html/as400/v4r5/ic2924/info/apis/connec.htm

It tells us here that the prototype for the connect() API looks like this:

int connect(int socket_descriptor,

struct sockaddr *destination_address,

int address_length)

So, as you can see, the procedure is named ’connect’, and it accepts 3 parameters. An integer, a pointer to a

’sockaddr’ structure, and another integer. It also returns an integer. This means that the RPG prototype will look like

this:

D connect PR 10I 0 ExtProc(’connect’)

D sock_desc 10I 0 value

D dest_addr * value

D addr_len 10I 0 value

Looking further down the manual, we see that the a ’sockaddr’ structure is deﬁned as follows:

struct sockaddr {

u_short sa_family;

char sa_data[14];

};

Remember, the purpose of this structure is to tell the API which IP address and port number to connect to. Why,

then, doesn’t it contain ﬁelds that we can put the address and port numbers into? Again, we have to remember that

the socket APIs can work with many different network protocols. Each protocol has a completely different format for

Chapter 3. Socket API calls to create our ﬁrst client program

how addresses work. This ’sockaddr’ structure is, therefore, a generic structure. It contains a place to put the

identifying address family, along with a generic "data" ﬁeld that the address can be placed in, regardless of the

format of the address.

Although it’s not documented on IBM’s page for the connect() API, there is actually a different structure called

’sockaddr_in’ which is designed especially for internet addresses. The C deﬁnition for sockaddr_in can be found in

the ﬁle QSYSINC/NETINET, member IN, if you have the System Openness Includes loaded. It looks like this:

struct sockaddr_in { /* socket address (internet) */

short sin_family; /* address family (AF_INET) */

u_short sin_port; /* port number */

struct in_addr sin_addr; /* IP address */

char sin_zero[8]; /* reserved - must be 0x00’s */

};

To make it easier to use these structures in RPG, I like to make them based in the same area of memory. This means

that you can look at the data as a ’sockaddr’, or the same data as a ’sockaddr_in’ without moving the data around.

Having said that, here’s the deﬁnition that I use for the sockaddr & sockaddr_in structures:

D p_sockaddr S *

D sockaddr DS based(p_sockaddr)

D sa_family 5I 0

D sa_data 14A

D sockaddr_in DS based(p_sockaddr)

D sin_family 5I 0

D sin_port 5U 0

D sin_addr 10U 0

D sin_zero 8A

Before we can call the connect() API, we need to ask the operating system for some memory that we can store our

sockaddr structure into. Then, we can populate the sockaddr_in structure, and actually call the connect() API. Like

so:

DName+++++++++++ETDsFrom+++To/L+++IDc.Keywords+++++++++++++++++++

D p_connto S *

D addrlen S 10I 0

C* Ask the operating system for some memory to store our socket

C* address into:

C eval addrlen = %size(sockaddr)

C alloc addrlen p_connto

C* Point the socket address structure at the newly allocated

C* area of memory:

C eval p_sockaddr = p_connto

C* Populate the sockaddr_in structure

C* Note that IP is the ip address we previously looked up

C* using the inet_addr and/or gethostbyname APIs

C* and port is the port number that we looked up using the

C* getservbyname API.

剩余170页未读，继续阅读

中国彭于晏杭州分晏

粉丝: 93
资源: 28

RPGIV编程语言中的网络编程：Sockets教程

ws2_32.lib.zip

CS423_UNIX_Domain_sockets_bwppt：cs423_unix_domain_sockets_bw.ppt

nss-3.67.0-4.el7_9.x86_64.rpm

#pragma comment(lib,"ws2_32.lib")

#pragma comment( lib, "ws2_32.lib" ) 是加在代码里吗，作用是什么

int port; port = 8000; m_addr.sin_family = AF_INET; m_addr.sin_addr.S_un.S_addr = inet_addr("192.168.85.150"); //m_addr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");//测试 m_addr.sin_port = ntohs(port); WSAConnect(m_s, (sockaddr*)&m_addr, sizeof(m_addr), NULL, NULL, NULL, NULL);

#pragma comment(lib,"ws2_32.lib")是干嘛的·1

activemq-cpp 库链接报错 cannot open input file ws2_32.lib 的可能原因

基于select模型,编写一个基于tcp协议的聊天室

基于select模式启动服务器，然后启动两个客户端 A 和 B，客户端 A 发消息给服务器，服务器转发给客户端 B ，客户端B打印显示接收到的消息。客户端B发消息给服务器，服务器转发给客户端A，客户端A打印显示接收到的消息。

python TCP 服务端实时监控所有客户端是否连接的程序

用python編寫socket多路複用

socket select 等待 accept 代码

仿qq聊天系统python

python socket 网络聊天的代码

yocto 编译adbd

#pragma comment(lib, "ws2_32.lib")是什么意思

用python写一个聊天室项目

基于socket的网络聊天室完整代码

python窗口化聊天

最新资源