-
s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下,以元组(host,port)的形式表示地址。
-
s.listen(backlog) 开始监听传入连接。backlog指定在拒绝连接之前,操作系统可以挂起的最大连接数量。该值至少为1,大部分应用程序设为5就可以了。
-
s.connect(address) 连接到address处的套接字。一般,address的格式为元组(hostname,port),如果连接同一台机器上的服务器,可以将hostname设为‘localhost’。如果连接出错,返回socket.error错误。
-
s.connect_ex(adddress) 功能与connect(address)相同,但是成功返回0,失败返回errno的值。
-
s.accept() 接受连接并返回(conn,address),其中conn是新的套接字对象,可以用来接收和发送数据。address是连接客户端的地址。
-
s.close() 关闭套接字。
-
s.fileno() 返回套接字的文件描述符。
-
s.getpeername() 返回连接套接字的远程地址。返回值通常是元组(ipaddr,port)。
-
s.getsockname() 返回套接字自己的地址。通常是一个元组(ipaddr,port)
-
s.getsockopt(level,optname[.buflen]) 返回套接字选项的值。
-
s.gettimeout() 返回当前超时期的值,单位是秒,如果没有设置超时期,则返回None。
-
s.recv(bufsize[,flag]) 接受套接字的数据。数据以字符串形式返回,bufsize指定要接收的最大数据量。flag提供有关消息的其他信息,通常可以忽略。
-
s.recvfrom(bufsize[.flag]) 与recv()类似,但返回值是(data,address)。其中data是包含接收数据的字符串,address是发送数据的套接字地址。
-
s.send(string[,flag]) 将string中的数据发送到连接的套接字。返回值是要发送的字节数量,该数量可能小于string的字节大小。
-
s.sendall(string[,flag]) 将string中的数据发送到连接的套接字,但在返回之前会尝试发送所有数据。成功返回None,失败则抛出异常。
-
s.sendto(string[,flag],address) 将数据发送到套接字,address是形式为(ipaddr,port)的元组,指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。
-
s.setblocking(flag) 如果flag为0,则将套接字设为非阻塞模式,否则将套接字设为阻塞模式(默认值)。非阻塞模式下,如果调用recv()没有发现任何数据,或send()调用无法立即发送数据,那么将引起socket.error异常。
-
s.setsockopt(level,optname,value) 设置给定套接字选项的值。
-
s.settimeout(timeout) 设置套接字操作的超时期,timeout是一个浮点数,单位是秒。值为None表示没有超时期。一般,超时期应该在刚创建套接字时设置,因为它们可能用于连接的操作(如connect())普通的非套接字实例的函数
-
getdefaulttimeout()返回默认的套接字超时时间(以秒为单位)。None表示不设置任何超时时间。
-
gethostbyname(hostname) 将主机名(如“www.baidu.com”)转换为IPv4地址,IP地址将以字符串的形式返回,如“8.8.8.8”。不支持IPv6
-
gethostname() 返回本地机器的主机名。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
Server.py 服务端
#Echo server program
import
socket
HOST
=
‘’
#空代表0.0.0.0
PORT
=
50007
#监听端口
s
=
socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 生成socket tcp通信实例,
s.bind((HOST,PORT))
#绑定ip和端口,注意bind只接受一个参数,(HOST,PORT) 做成一个元祖传进去
s.listen(
1
)
#开始监听,里面的数字是代表服务端在拒绝新连接之前可以最多挂起多少连接,不过实验过了没啥用,所以写个1就好了
conn,addr
=
s.accept()
#接受连接,并返回两个变量,conn代表每个新连接进入后服务端都会为其生成一个新实例,后面可以用这个实例进行发送和接收,addr是连接进来的客户端的地址,accept()方法在有新连接进入时就会返回conn,addr这两个变量,但如果没有连接时,此方法就会阻塞直至有新连接过来。
print
'Connected by'
, addr
while
True
:
data
=
conn.recv(
1024
)
#接收1024字节数据
if
not
data:
break
#如果收不到客户端数据了(代表客户端断开了),就断开
conn.sendall(data.upper())
#将收到的数据全变成大写再发给客户端
conn.close()
#关闭连接
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
Client.py 客户端
import
socket
HOST
=
'192.168.3.1'
# 远程socket服务器ip
PORT
=
50007
# 远程socket服务器端口
s
=
socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#实例化socket
s.connect((HOST,PORT))
#连接socket服务器
while
True
:
msg
=
raw_input
(
"Your msg::"
).strip()
#让用户输入消息,去除回车和空格
if
len
(msg)
=
=
0
:
continue
s.sendall(msg)
#向服务器发送消息
data
=
s.recv(
1024
)
#接收服务器的消息
print
'Received:'
, data
s.close()
|
1
|
if
not
data:
break
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
#Echo server program
import
socket
HOST
=
''
#空代表0.0.0.0
PORT
=
50007
#监听端口
s
=
socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind((HOST,PORT))
s.listen(
1
)
while
True
:
conn,addr
=
s.accept()
print
'Connected by'
, addr
while
True
:
data
=
conn.recv(
1024
)
#接收1024字节数据
if
not
data:
break
#如果收不到客户端数据了(代表客户端断开了),就断开
conn.sendall(data.upper())
#将收到的数据全变成大写再发给客户端
conn.close()
#关闭此客户端的连接实例
|
1
|
conn,addr
=
s.accept()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
import
SocketServer
class
MyTCPHandler(SocketServer.BaseRequestHandler):
#继承BaseRequestHandler基类,然后必须重写handle方法,并且在handle方法里实现与客户端的所有交互
def
handle(
self
):
while
True
:
data
=
self
.request.recv(
1024
)
#接收1024字节数据
if
not
data:
break
self
.request.sendall(data.upper())
if
__name__
=
=
"__main__"
:
HOST, PORT
=
"localhost"
,
50007
# 把刚才写的类当作一个参数传给ThreadingTCPServer这个类,下面的代码就创建了一个多线程socket server
server
=
SocketServer.ThreadingTCPServer((HOST, PORT), MyTCPHandler)
# 启动这个server,这个server会一直运行,除非按ctrl-C停止
server.serve_forever()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
|
#_*_coding:utf-8_*_
__author__
=
'jieli'
import
socket
import
os
class
FtpClient(
object
):
def
__init__(
self
,host,port ):
self
.sock
=
socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self
.sock.connect((host, port))
#连接服务器
def
start(
self
):
#实例化客户端类后,需要调用此方法启动客户端
self
.interactive()
#跟用户的交互都在这个方法里
def
interactive(
self
):
while
True
:
user_input
=
raw_input
(
">>:"
).strip()
if
len
(user_input)
=
=
0
:
continue
user_input
=
user_input.split()
#用户输入的指令进行拆分,第一个参数是指要进行什么动作,比如get remote_filename
if
hasattr
(
self
,user_input[
0
]):
#判断类中是否有get或其它输入的方法
func
=
getattr
(
self
,user_input[
0
])
#通过字符串获取类中对应方法的内存对象
func(user_input)
#调用此内存对象
else
:
print
"\033[31;1mWrong cmd usage\033[0m"
def
get(
self
,msg):
#从服务器端下载文件
print
'--get func---'
,msg
if
len
(msg)
=
=
2
:
file_name
=
msg[
1
]
instruction
=
"FileTransfer|get|%s"
%
file_name
#告诉服务器端要下载什么文件
self
.sock.send(instruction)
feedback
=
self
.sock.recv(
100
)
#等待服务器端的消息确认
print
'-->'
,feedback
if
feedback.startswith(
"FileTransfer|get|ready"
):
#代表服务器上文件存在,并且服务器已经准备好了发送此文件到客户端
file_size
=
int
(feedback.split(
"|"
)[
-
1
])
# 服务器端发回来的确认消息中,最后面一个值是文件大小,必须知道文件大小才知道一共要收多少内容
self
.sock.send(
"FileTransfer|get|recv_ready"
)
#告诉服务器端已经准备好了接收
recv_size
=
0
# 因为文件可能会比较大,一次收不完,所以要循环收,每收到一次,就计个数
f
=
file
(
'client_recv/%s'
%
os.path.basename(file_name),
'wb'
)
#在本地创建一个新文件来存这个要下载的文件内容
print
'--->'
,file_name
while
not
file_size
=
=
recv_size:
#只要文件总大小和已收到的大小不想等,就代表还没收完
if
file_size
-
recv_size>
1024
:
#文件总大下减已收到的大小等于还剩下没收到的大小,如果这个数大于1024,代表一次肯定收不完,那就还得多循环几次
data
=
self
.sock.recv(
1024
)
#这次收1024字节,但实际上收到的可能比1024小,所以需要以实际收到的数为准
recv_size
+
=
len
(data)
# 已收到的大小加上这一次循环收到的实际大小
else
:
# 如果最后剩下的少于1024,那就一次性把剩下的都收过来
data
=
self
.sock.recv(file_size
-
recv_size)
#recv_size = file_size #不能这么写,因为这一次依然不一定能一次性收完,因为实际收到的数据可能比你规定的数据要少, 所以需要按下面这行的方式写
recv_size
+
=
(file_size
-
recv_size)
f.write(data)
#收到的内容写入文件
print
file_size,recv_size
else
:
print
'---recv file:%s---'
%
file_name
f.close()
else
:
print
feedback
else
:
print
"\033[31;1mWrong cmd usage\033[0m"
def
put(
self
):
pass
def
ls(
self
):
pass
def
cd(
self
):
pass
def
delete(
self
):
pass
if
__name__
=
=
"__main__"
:
f
=
FtpClient(
'localhost'
,
9002
)
f.start()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
#_*_coding:utf-8_*_
import
SocketServer
import
os
class
MyTCPHandler(SocketServer.BaseRequestHandler):
def
handle(
self
):
while
True
:
instruction
=
self
.request.recv(
1024
).strip()
#接收客户端命令
if
not
instruction :
break
instruction
=
instruction.split(
'|'
)
#将客户端发过来的消息按|来拆分,消息类似这种格式 “FileTransfer|get|file_name”
if
hasattr
(
self
,instruction[
0
]):
#判断类中是否有这个方法
func
=
getattr
(
self
, instruction[
0
])
#获取这个方法的内存对象
func(instruction)
#调用此方法
def
FileTransfer(
self
,msg):
#负责文件的发送和接收
print
'---filetransfer---'
,msg
if
msg[
1
]
=
=
'get'
:
#如果客户端发来的指令是get,那就是下载文件
print
"client wants to download file:"
, msg[
2
]
if
os.path.isfile(msg[
2
]):
#判断客户端发的文件名是否存在并是个文件
file_size
=
os.path.getsize(msg[
2
])
# 获取文件大小
res
=
"ready|%s"
%
file_size
# 把文件大小告诉客户端
else
:
res
=
"file doesn't exist"
#文件也有可能不存在
send_confirmation
=
"FileTransfer|get|%s"
%
res
self
.request.send(send_confirmation)
# 发送确认消息给客户端
feedback
=
self
.request.recv(
100
)
#等待客户端确认, 如果这时不等客户端确认就立刻给客户端发文件内容,因为为了减少IO操作,socket发送和接收是有缓冲区的,缓冲区满了才会发送,那上一条消息很有可能会和文件内容的一部分被合并成一条消息发给客户端,这就行成了粘包,所以这里等待客户端的一个确认消息,就把两次发送分开了,不会再有粘包
if
feedback
=
=
'FileTransfer|get|recv_ready'
:
#如果客户端说准备好接收了
f
=
file
(msg[
2
],
'rb'
)
send_size
=
0
#发送的逻辑跟客户端循环接收的逻辑是一样的
while
not
file_size
=
=
send_size :
if
file_size
-
send_size >
1024
:
data
=
f.read(
1024
)
send_size
+
=
1024
else
:
#left data less than 1024
data
=
f.read(file_size
-
send_size)
send_size
+
=
(file_size
-
send_size)
self
.request.send(data)
print
file_size,send_size
else
:
print
'---send file:%s done----'
%
msg[
2
]
f.close()
elif
msg[
1
]
=
=
'put'
:
pass
if
__name__
=
=
'__main__'
:
HOST, PORT
=
"",
9002
server
=
SocketServer.ThreadingTCPServer((HOST, PORT), MyTCPHandler)
server.serve_forever()
|