python----socket编程（一）

一 客户端/服务器架构
二 osi七层

三 socket层

四 socket是什么

五 套接字发展史及分类

六 套接字工作流程

七 基于TCP的套接字

八 基于UDP的套接字

九 recv与recvfrom的区别

十 粘包现象

十一 什么是粘包

十二 解决粘包的low比处理方法

十三 解决粘包的方法

十四 认证客户端的链接合法性

十五 socketserver实现并发

from socket import *

phone=socket(AF_INET,SOCK_STREAM)

phone.bind((‘127.0.0.1‘,8081))

phone.listen(5)

 

conn,addr=phone.accept()

while True:

    data=conn.recv(1024)

    print(‘server===>‘)

    print(data)

    conn.send(data.upper())

conn.close()

phone.close()

from socket import *

 

phone=socket(AF_INET,SOCK_STREAM)

phone.connect((‘127.0.0.1‘,8081))

 

while True:

    msg=input(‘>>: ‘).strip()

    phone.send(msg.encode(‘utf-8‘))

    print(‘client====>‘)

    data=phone.recv(1024)

    print(data)

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket

ip_port=(‘127.0.0.1‘,9000)  #电话卡

BUFSIZE=1024                #收发消息的尺寸

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机

s.bind(ip_port) #手机插卡

s.listen(5)     #手机待机

 

 

conn,addr=s.accept()            #手机接电话

# print(conn)

# print(addr)

print(‘接到来自%s的电话‘ %addr[0])

 

msg=conn.recv(BUFSIZE)             #听消息,听话

print(msg,type(msg))

 

conn.send(msg.upper())          #发消息,说话

 

conn.close()                    #挂电话

 

s.close()                       #手机关机

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket

ip_port=(‘127.0.0.1‘,9000)

BUFSIZE=1024

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

 

s.connect_ex(ip_port)           #拨电话

 

s.send(‘linhaifeng nb‘.encode(‘utf-8‘))         #发消息,说话(只能发送字节类型)

 

feedback=s.recv(BUFSIZE)                           #收消息,听话

print(feedback.decode(‘utf-8‘))

 

s.close()                                       #挂电话

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket

ip_port=(‘127.0.0.1‘,8081)#电话卡

BUFSIZE=1024

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机

s.bind(ip_port) #手机插卡

s.listen(5)     #手机待机

 

 

while True:                         #新增接收链接循环,可以不停的接电话

    conn,addr=s.accept()            #手机接电话

    # print(conn)

    # print(addr)

    print(‘接到来自%s的电话‘ %addr[0])

    while True:                         #新增通信循环,可以不断的通信,收发消息

        msg=conn.recv(BUFSIZE)             #听消息,听话

 

        # if len(msg) == 0:break        #如果不加,那么正在链接的客户端突然断开,recv便不再阻塞,死循环发生

 

        print(msg,type(msg))

 

        conn.send(msg.upper())          #发消息,说话

 

    conn.close()                    #挂电话

 

s.close()                       #手机关机

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket

ip_port=(‘127.0.0.1‘,8081)

BUFSIZE=1024

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

 

s.connect_ex(ip_port)           #拨电话

 

while True:                             #新增通信循环,客户端可以不断发收消息

    msg=input(‘>>: ‘).strip()

    if len(msg) == 0:continue

    s.send(msg.encode(‘utf-8‘))         #发消息,说话(只能发送字节类型)

 

    feedback=s.recv(BUFSIZE)                           #收消息,听话

    print(feedback.decode(‘utf-8‘))

 

s.close()                                       #挂电话

 

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket

ip_port=(‘127.0.0.1‘,9000)

BUFSIZE=1024

udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

 

udp_server_client.bind(ip_port)

 

while True:

    msg,addr=udp_server_client.recvfrom(BUFSIZE)

    print(msg,addr)

 

    udp_server_client.sendto(msg.upper(),addr)

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket

ip_port=(‘127.0.0.1‘,9000)

BUFSIZE=1024

udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

 

while True:

    msg=input(‘>>: ‘).strip()

    if not msg:continue

 

    udp_server_client.sendto(msg.encode(‘utf-8‘),ip_port)

 

    back_msg,addr=udp_server_client.recvfrom(BUFSIZE)

    print(back_msg.decode(‘utf-8‘),addr)

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket

ip_port=(‘127.0.0.1‘,8081)

udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #买手机

udp_server_sock.bind(ip_port)

 

while True:

    qq_msg,addr=udp_server_sock.recvfrom(1024)

    print(‘来自[%s:%s]的一条消息:\033[1;44m%s\033[0m‘ %(addr[0],addr[1],qq_msg.decode(‘utf-8‘)))

    back_msg=input(‘回复消息: ‘).strip()

 

    udp_server_sock.sendto(back_msg.encode(‘utf-8‘),addr)

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket

BUFSIZE=1024

udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

 

qq_name_dic={

    ‘狗哥alex‘:(‘127.0.0.1‘,8081),

    ‘瞎驴‘:(‘127.0.0.1‘,8081),

    ‘一棵树‘:(‘127.0.0.1‘,8081),

    ‘武大郎‘:(‘127.0.0.1‘,8081),

}

 

 

while True:

    qq_name=input(‘请选择聊天对象: ‘).strip()

    while True:

        msg=input(‘请输入消息,回车发送: ‘).strip()

        if msg == ‘quit‘:break

        if not msg or not qq_name or qq_name not in qq_name_dic:continue

        udp_client_socket.sendto(msg.encode(‘utf-8‘),qq_name_dic[qq_name])

 

        back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)

        print(‘来自[%s:%s]的一条消息:\033[1;44m%s\033[0m‘ %(addr[0],addr[1],back_msg.decode(‘utf-8‘)))

 

udp_client_socket.close()

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket

BUFSIZE=1024

udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

 

qq_name_dic={

    ‘狗哥alex‘:(‘127.0.0.1‘,8081),

    ‘瞎驴‘:(‘127.0.0.1‘,8081),

    ‘一棵树‘:(‘127.0.0.1‘,8081),

    ‘武大郎‘:(‘127.0.0.1‘,8081),

}

 

 

while True:

    qq_name=input(‘请选择聊天对象: ‘).strip()

    while True:

        msg=input(‘请输入消息,回车发送: ‘).strip()

        if msg == ‘quit‘:break

        if not msg or not qq_name or qq_name not in qq_name_dic:continue

        udp_client_socket.sendto(msg.encode(‘utf-8‘),qq_name_dic[qq_name])

 

        back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)

        print(‘来自[%s:%s]的一条消息:\033[1;44m%s\033[0m‘ %(addr[0],addr[1],back_msg.decode(‘utf-8‘)))

 

udp_client_socket.close()

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

from socket import *

from time import strftime

 

ip_port=(‘127.0.0.1‘,9000)

bufsize=1024

 

tcp_server=socket(AF_INET,SOCK_DGRAM)

tcp_server.bind(ip_port)

 

while True:

    msg,addr=tcp_server.recvfrom(bufsize)

    print(‘===>‘,msg)

   

    if not msg:

        time_fmt=‘%Y-%m-%d %X‘

    else:

        time_fmt=msg.decode(‘utf-8‘)

    back_msg=strftime(time_fmt)

 

    tcp_server.sendto(back_msg.encode(‘utf-8‘),addr)

 

tcp_server.close()

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

from socket import *

ip_port=(‘127.0.0.1‘,9000)

bufsize=1024

 

tcp_client=socket(AF_INET,SOCK_DGRAM)

 

 

 

while True:

    msg=input(‘请输入时间格式(例%Y %m %d)>>: ‘).strip()

    tcp_client.sendto(msg.encode(‘utf-8‘),ip_port)

 

    data=tcp_client.recv(bufsize)

 

    print(data.decode(‘utf-8‘))

 

tcp_client.close()

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import subprocess

from socket import *

 

phone=socket(AF_INET,SOCK_STREAM)

phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)

phone.bind((‘127.0.0.1‘,8080))

phone.listen(5)

 

conn,addr=phone.accept()

 

while True:

    data=conn.recv(1024)

    print(‘from client msg is ‘,data)

    conn.send(data.upper())

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import subprocess

from socket import *

 

phone=socket(AF_INET,SOCK_STREAM)

phone.connect((‘127.0.0.1‘,8080))

 

 

while True:

    msg=input(‘>>: ‘)

    phone.send(msg.encode(‘utf-8‘))

    print(‘Client message has been sent‘)

 

    data=phone.recv(1024)

    print(‘from server msg is ‘,data.decode(‘utf-8‘))

phone.close()

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

from socket import *

 

ip_port=(‘127.0.0.1‘,9003)

bufsize=1024

 

udp_server=socket(AF_INET,SOCK_DGRAM)

udp_server.bind(ip_port)

 

while True:

    data1,addr=udp_server.recvfrom(bufsize)

    print(data1)

 

 

 

 

from socket import *

ip_port=(‘127.0.0.1‘,9003)

bufsize=1024

 

udp_client=socket(AF_INET,SOCK_DGRAM)

 

while True:

    msg=input(‘>>: ‘)

    udp_client.sendto(msg.encode(‘utf-8‘),ip_port) #发送空,发现服务端可以接收空

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

from socket import *

 

ip_port=(‘127.0.0.1‘,9003)

bufsize=1024

 

udp_server=socket(AF_INET,SOCK_DGRAM)

udp_server.bind(ip_port)

 

data1,addr=udp_server.recvfrom(1)

print(‘第一次收了 ‘,data1)

data2,addr=udp_server.recvfrom(1)

print(‘第二次收了 ‘,data2)

data3,addr=udp_server.recvfrom(1)

print(‘第三次收了 ‘,data3)

print(‘--------结束----------‘)

 

 

 

from socket import *

ip_port=(‘127.0.0.1‘,9003)

bufsize=1024

 

udp_client=socket(AF_INET,SOCK_DGRAM)

 

udp_client.sendto(b‘hello‘,ip_port)

udp_client.sendto(b‘world‘,ip_port)

udp_client.sendto(b‘egon‘,ip_port)

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

from socket import *

 

ip_port=(‘127.0.0.1‘,9003)

bufsize=1024

 

udp_server=socket(AF_INET,SOCK_DGRAM)

udp_server.bind(ip_port)

 

data1,addr=udp_server.recvfrom(bufsize)

print(‘第一次收了 ‘,data1)

data2,addr=udp_server.recvfrom(bufsize)

print(‘第二次收了 ‘,data2)

data3,addr=udp_server.recvfrom(bufsize)

print(‘第三次收了 ‘,data3)

print(‘--------结束----------‘)

 

 

 

 

from socket import *

import time

ip_port=(‘127.0.0.1‘,9003)

bufsize=1024

 

udp_client=socket(AF_INET,SOCK_DGRAM)

 

udp_client.sendto(b‘hello‘,ip_port)

udp_client.sendto(b‘world‘,ip_port)

udp_client.sendto(b‘egon‘,ip_port)

 

print(‘客户端发完消息啦‘)

time.sleep(100)

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

from socket import *

import subprocess

 

ip_port=(‘127.0.0.1‘,8080)

BUFSIZE=1024

 

tcp_socket_server=socket(AF_INET,SOCK_STREAM)

tcp_socket_server.bind(ip_port)

tcp_socket_server.listen(5)

 

while True:

    conn,addr=tcp_socket_server.accept()

    print(‘客户端‘,addr)

 

    while True:

        cmd=conn.recv(BUFSIZE)

        if len(cmd) == 0:break

 

        act_res=subprocess.Popen(cmd.decode(‘utf-8‘),shell=True,

                         stdout=subprocess.PIPE,

                         stdin=subprocess.PIPE,

                         stderr=subprocess.PIPE)

 

        act_err=act_res.stderr.read()

        if act_err:

            ret=act_err

        else:

            ret=act_res.stdout.read()

 

        conn.sendall(ret)

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket

BUFSIZE=1024

ip_port=(‘127.0.0.1‘,8080)

 

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

res=s.connect_ex(ip_port)

 

while True:

    msg=input(‘>>: ‘).strip()

    if len(msg) == 0:continue

    if msg == ‘quit‘:break

 

    s.send(msg.encode(‘utf-8‘))

    act_res=s.recv(BUFSIZE)

 

    print(act_res.decode(‘utf-8‘),end=‘‘)

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

from socket import *

import subprocess

 

ip_port=(‘127.0.0.1‘,9003)

bufsize=1024

 

udp_server=socket(AF_INET,SOCK_DGRAM)

udp_server.bind(ip_port)

 

while True:

    #收消息

    cmd,addr=udp_server.recvfrom(bufsize)

    print(‘用户命令----->‘,cmd)

 

    #逻辑处理

    res=subprocess.Popen(cmd.decode(‘utf-8‘),shell=True,stderr=subprocess.PIPE,stdin=subprocess.PIPE,stdout=subprocess.PIPE)

    err=res.stderr.read()

    print(‘错误====>‘,err)

    if err:

        back_msg=err

    else:

        back_msg=res.stdout.read()

    print(‘返回结果‘,back_msg)

 

    #发消息

    udp_server.sendto(back_msg,addr)

udp_server.close()

 

 

 

from socket import *

ip_port=(‘127.0.0.1‘,9003)

bufsize=1024

 

udp_client=socket(AF_INET,SOCK_DGRAM)

 

 

while True:

    msg=input(‘>>: ‘).strip()

    udp_client.sendto(msg.encode(‘utf-8‘),ip_port)

 

    data,addr=udp_client.recvfrom(bufsize)

    print(data.decode(‘utf-8‘),end=‘‘)

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

from socket import *

ip_port=(‘127.0.0.1‘,8080)

 

tcp_socket_server=socket(AF_INET,SOCK_STREAM)

tcp_socket_server.bind(ip_port)

tcp_socket_server.listen(5)

 

 

conn,addr=tcp_socket_server.accept()

 

 

data1=conn.recv(10)

data2=conn.recv(10)

 

print(‘----->‘,data1.decode(‘utf-8‘))

print(‘----->‘,data2.decode(‘utf-8‘))

 

conn.close()

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket

BUFSIZE=1024

ip_port=(‘127.0.0.1‘,8080)

 

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

res=s.connect_ex(ip_port)

 

 

s.send(‘hello‘.encode(‘utf-8‘))

s.send(‘feng‘.encode(‘utf-8‘))

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

from socket import *

ip_port=(‘127.0.0.1‘,8080)

 

tcp_socket_server=socket(AF_INET,SOCK_STREAM)

tcp_socket_server.bind(ip_port)

tcp_socket_server.listen(5)

 

 

conn,addr=tcp_socket_server.accept()

 

 

data1=conn.recv(2) #一次没有收完整

data2=conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的

 

print(‘----->‘,data1.decode(‘utf-8‘))

print(‘----->‘,data2.decode(‘utf-8‘))

 

conn.close()

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket

BUFSIZE=1024

ip_port=(‘127.0.0.1‘,8080)

 

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

res=s.connect_ex(ip_port)

 

 

s.send(‘hello feng‘.encode(‘utf-8‘))

 

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket,subprocess

ip_port=(‘127.0.0.1‘,8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

 

s.bind(ip_port)

s.listen(5)

 

while True:

    conn,addr=s.accept()

    print(‘客户端‘,addr)

    while True:

        msg=conn.recv(1024)

        if not msg:break

        res=subprocess.Popen(msg.decode(‘utf-8‘),shell=True,
                            stdin=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         stdout=subprocess.PIPE)

        err=res.stderr.read()

        if err:

            ret=err

        else:

            ret=res.stdout.read()

        data_length=len(ret)

        conn.send(str(data_length).encode(‘utf-8‘))

        data=conn.recv(1024).decode(‘utf-8‘)

        if data == ‘recv_ready‘:

            conn.sendall(ret)

    conn.close()

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket,time

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

res=s.connect_ex((‘127.0.0.1‘,8080))

 

while True:

    msg=input(‘>>: ‘).strip()

    if len(msg) == 0:continue

    if msg == ‘quit‘:break

 

    s.send(msg.encode(‘utf-8‘))

    length=int(s.recv(1024).decode(‘utf-8‘))

    s.send(‘recv_ready‘.encode(‘utf-8‘))

    send_size=0

    recv_size=0

    data=b‘‘

    while recv_size < length:

        data+=s.recv(1024)

        recv_size+=len(data)

 

 

    print(data.decode(‘utf-8‘))

 

 

#_*_coding:utf-8_*_

#http://www.cnblogs.com/coser/archive/2011/12/17/2291160.html

__author__ = ‘Linhaifeng‘

import struct

import binascii

import ctypes

 

values1 = (1, ‘abc‘.encode(‘utf-8‘), 2.7)

values2 = (‘defg‘.encode(‘utf-8‘),101)

s1 = struct.Struct(‘I3sf‘)

s2 = struct.Struct(‘4sI‘)

 

print(s1.size,s2.size)

prebuffer=ctypes.create_string_buffer(s1.size+s2.size)

print(‘Before : ‘,binascii.hexlify(prebuffer))

# t=binascii.hexlify(‘asdfaf‘.encode(‘utf-8‘))

# print(t)

 

 

s1.pack_into(prebuffer,0,*values1)

s2.pack_into(prebuffer,s1.size,*values2)

 

print(‘After pack‘,binascii.hexlify(prebuffer))

print(s1.unpack_from(prebuffer,0))

print(s2.unpack_from(prebuffer,s1.size))

 

s3=struct.Struct(‘ii‘)

s3.pack_into(prebuffer,0,123,123)

print(‘After pack‘,binascii.hexlify(prebuffer))

print(s3.unpack_from(prebuffer,0))

 

 

 

 

import socket,struct,json

import subprocess

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加

 

phone.bind((‘127.0.0.1‘,8080))

 

phone.listen(5)

 

while True:

    conn,addr=phone.accept()

    while True:

        cmd=conn.recv(1024)

        if not cmd:break

        print(‘cmd: %s‘ %cmd)

 

        res=subprocess.Popen(cmd.decode(‘utf-8‘),

                             shell=True,

                             stdout=subprocess.PIPE,

                             stderr=subprocess.PIPE)

        err=res.stderr.read()

        print(err)

        if err:

            back_msg=err

        else:

            back_msg=res.stdout.read()

 

 

        conn.send(struct.pack(‘i‘,len(back_msg))) #先发back_msg的长度

        conn.sendall(back_msg) #在发真实的内容

 

    conn.close()

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

import socket,time,struct

 

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

res=s.connect_ex((‘127.0.0.1‘,8080))

 

while True:

    msg=input(‘>>: ‘).strip()

    if len(msg) == 0:continue

    if msg == ‘quit‘:break

 

    s.send(msg.encode(‘utf-8‘))

 

 

 

    l=s.recv(4)

    x=struct.unpack(‘i‘,l)[0]

    print(type(x),x)

    # print(struct.unpack(‘I‘,l))

    r_s=0

    data=b‘‘

    while r_s < x:

        r_d=s.recv(1024)

        data+=r_d

        r_s+=len(r_d)

 

    # print(data.decode(‘utf-8‘))

    print(data.decode(‘gbk‘)) #windows默认gbk编码

import socket,struct,json

import subprocess

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加

 

phone.bind((‘127.0.0.1‘,8080))

 

phone.listen(5)

 

while True:

    conn,addr=phone.accept()

    while True:

        cmd=conn.recv(1024)

        if not cmd:break

        print(‘cmd: %s‘ %cmd)

 

        res=subprocess.Popen(cmd.decode(‘utf-8‘),

                             shell=True,

                             stdout=subprocess.PIPE,

                             stderr=subprocess.PIPE)

        err=res.stderr.read()

        print(err)

        if err:

            back_msg=err

        else:

            back_msg=res.stdout.read()

 

        headers={‘data_size‘:len(back_msg)}

        head_json=json.dumps(headers)

        head_json_bytes=bytes(head_json,encoding=‘utf-8‘)

 

        conn.send(struct.pack(‘i‘,len(head_json_bytes))) #先发报头的长度

        conn.send(head_json_bytes) #再发报头

        conn.sendall(back_msg) #在发真实的内容

 

    conn.close()

 

 

 

from socket import *

import struct,json

 

ip_port=(‘127.0.0.1‘,8080)

client=socket(AF_INET,SOCK_STREAM)

client.connect(ip_port)

 

while True:

    cmd=input(‘>>: ‘)

    if not cmd:continue

    client.send(bytes(cmd,encoding=‘utf-8‘))

 

    head=client.recv(4)

    head_json_len=struct.unpack(‘i‘,head)[0]

    head_json=json.loads(client.recv(head_json_len).decode(‘utf-8‘))

    data_len=head_json[‘data_size‘]

 

    recv_size=0

    recv_data=b‘‘

    while recv_size < data_len:

        recv_data+=client.recv(1024)

        recv_size+=len(recv_data)

 

    print(recv_data.decode(‘utf-8‘))

    #print(recv_data.decode(‘gbk‘)) #windows默认gbk编码

 

 

import socket

import struct

import json

import subprocess

import os

 

class MYTCPServer:

    address_family = socket.AF_INET

 

    socket_type = socket.SOCK_STREAM

 

    allow_reuse_address = False

 

    max_packet_size = 8192

 

    coding=‘utf-8‘

 

    request_queue_size = 5

 

    server_dir=‘file_upload‘

 

    def __init__(self, server_address, bind_and_activate=True):

        """Constructor.  May be extended, do not override."""

        self.server_address=server_address

        self.socket = socket.socket(self.address_family,

                                    self.socket_type)

        if bind_and_activate:

            try:

                self.server_bind()

                self.server_activate()

            except:

                self.server_close()

                raise

 

    def server_bind(self):

        """Called by constructor to bind the socket.

        """

        if self.allow_reuse_address:

            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

        self.socket.bind(self.server_address)

        self.server_address = self.socket.getsockname()

 

    def server_activate(self):

        """Called by constructor to activate the server.

        """

        self.socket.listen(self.request_queue_size)

 

    def server_close(self):

        """Called to clean-up the server.

        """

        self.socket.close()

 

    def get_request(self):

        """Get the request and client address from the socket.

        """

        return self.socket.accept()

 

    def close_request(self, request):

        """Called to clean up an individual request."""

        request.close()

 

    def run(self):

        while True:

            self.conn,self.client_addr=self.get_request()

            print(‘from client ‘,self.client_addr)

            while True:

                try:

                    head_struct = self.conn.recv(4)

                    if not head_struct:break

 

                    head_len = struct.unpack(‘i‘, head_struct)[0]

                    head_json = self.conn.recv(head_len).decode(self.coding)

                    head_dic = json.loads(head_json)

 

                    print(head_dic)

                    #head_dic={‘cmd‘:‘put‘,‘filename‘:‘a.txt‘,‘filesize‘:123123}

                    cmd=head_dic[‘cmd‘]

                    if hasattr(self,cmd):

                        func=getattr(self,cmd)

                        func(head_dic)

                except Exception:

                    break

 

    def put(self,args):

        file_path=os.path.normpath(os.path.join(

            self.server_dir,

            args[‘filename‘]

        ))

 

        filesize=args[‘filesize‘]

        recv_size=0

        print(‘----->‘,file_path)

        with open(file_path,‘wb‘) as f:

            while recv_size < filesize:

                recv_data=self.conn.recv(self.max_packet_size)

                f.write(recv_data)

                recv_size+=len(recv_data)

                print(‘recvsize:%s filesize:%s‘ %(recv_size,filesize))

 

 

tcpserver1=MYTCPServer((‘127.0.0.1‘,8080))

 

tcpserver1.run()

 

 

 

 

 

class MYUDPServer:

 

    """UDP server class."""

    address_family = socket.AF_INET

 

    socket_type = socket.SOCK_DGRAM

 

    allow_reuse_address = False

 

    max_packet_size = 8192

 

    coding=‘utf-8‘

 

    def get_request(self):

        data, client_addr = self.socket.recvfrom(self.max_packet_size)

        return (data, self.socket), client_addr

 

    def server_activate(self):

        # No need to call listen() for UDP.

        pass

 

    def shutdown_request(self, request):

        # No need to shutdown anything.

        self.close_request(request)

 

    def close_request(self, request):

        # No need to close anything.

        pass

 

 

 

import socket

import struct

import json

import os

 

 

 

class MYTCPClient:

    address_family = socket.AF_INET

 

    socket_type = socket.SOCK_STREAM

 

    allow_reuse_address = False

 

    max_packet_size = 8192

 

    coding=‘utf-8‘

 

    request_queue_size = 5

 

    def __init__(self, server_address, connect=True):

        self.server_address=server_address

        self.socket = socket.socket(self.address_family,

                                    self.socket_type)

        if connect:

            try:

                self.client_connect()

            except:

                self.client_close()

                raise

 

    def client_connect(self):

        self.socket.connect(self.server_address)

 

    def client_close(self):

        self.socket.close()

 

    def run(self):

        while True:

            inp=input(">>: ").strip()

            if not inp:continue

            l=inp.split()

            cmd=l[0]

            if hasattr(self,cmd):

                func=getattr(self,cmd)

                func(l)

 

 

    def put(self,args):

        cmd=args[0]

        filename=args[1]

        if not os.path.isfile(filename):

            print(‘file:%s is not exists‘ %filename)

            return

        else:

            filesize=os.path.getsize(filename)

 

        head_dic={‘cmd‘:cmd,‘filename‘:os.path.basename(filename),‘filesize‘:filesize}

        print(head_dic)

        head_json=json.dumps(head_dic)

        head_json_bytes=bytes(head_json,encoding=self.coding)

 

        head_struct=struct.pack(‘i‘,len(head_json_bytes))

        self.socket.send(head_struct)

        self.socket.send(head_json_bytes)

        send_size=0

        with open(filename,‘rb‘) as f:

            for line in f:

                self.socket.send(line)

                send_size+=len(line)

                print(send_size)

            else:

                print(‘upload successful‘)

 

 

 

 

client=MYTCPClient((‘127.0.0.1‘,8080))

 

client.run()

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

from socket import *

import hmac,os

 

secret_key=b‘linhaifeng bang bang bang‘

def conn_auth(conn):

    ‘‘‘

    认证客户端链接

    :param conn:

    :return:

    ‘‘‘

    print(‘开始验证新链接的合法性‘)

    msg=os.urandom(32)

    conn.sendall(msg)

    h=hmac.new(secret_key,msg)

    digest=h.digest()

    respone=conn.recv(len(digest))

    return hmac.compare_digest(respone,digest)

 

def data_handler(conn,bufsize=1024):

    if not conn_auth(conn):

        print(‘该链接不合法,关闭‘)

        conn.close()

        return

    print(‘链接合法,开始通信‘)

    while True:

        data=conn.recv(bufsize)

        if not data:break

        conn.sendall(data.upper())

 

def server_handler(ip_port,bufsize,backlog=5):

    ‘‘‘

    只处理链接

    :param ip_port:

    :return:

    ‘‘‘

    tcp_socket_server=socket(AF_INET,SOCK_STREAM)

    tcp_socket_server.bind(ip_port)

    tcp_socket_server.listen(backlog)

    while True:

        conn,addr=tcp_socket_server.accept()

        print(‘新连接[%s:%s]‘ %(addr[0],addr[1]))

        data_handler(conn,bufsize)

 

if __name__ == ‘__main__‘:

    ip_port=(‘127.0.0.1‘,9999)

    bufsize=1024

    server_handler(ip_port,bufsize)

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

from socket import *

import hmac,os

 

secret_key=b‘linhaifeng bang bang bang‘

def conn_auth(conn):

    ‘‘‘

    验证客户端到服务器的链接

    :param conn:

    :return:

    ‘‘‘

    msg=conn.recv(32)

    h=hmac.new(secret_key,msg)

    digest=h.digest()

    conn.sendall(digest)

 

def client_handler(ip_port,bufsize=1024):

    tcp_socket_client=socket(AF_INET,SOCK_STREAM)

    tcp_socket_client.connect(ip_port)

 

    conn_auth(tcp_socket_client)

 

    while True:

        data=input(‘>>: ‘).strip()

        if not data:continue

        if data == ‘quit‘:break

 

        tcp_socket_client.sendall(data.encode(‘utf-8‘))

        respone=tcp_socket_client.recv(bufsize)

        print(respone.decode(‘utf-8‘))

    tcp_socket_client.close()

 

if __name__ == ‘__main__‘:

    ip_port=(‘127.0.0.1‘,9999)

    bufsize=1024

    client_handler(ip_port,bufsize)

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

from socket import *

 

def client_handler(ip_port,bufsize=1024):

    tcp_socket_client=socket(AF_INET,SOCK_STREAM)

    tcp_socket_client.connect(ip_port)

 

    while True:

        data=input(‘>>: ‘).strip()

        if not data:continue

        if data == ‘quit‘:break

 

        tcp_socket_client.sendall(data.encode(‘utf-8‘))

        respone=tcp_socket_client.recv(bufsize)

        print(respone.decode(‘utf-8‘))

    tcp_socket_client.close()

 

if __name__ == ‘__main__‘:

    ip_port=(‘127.0.0.1‘,9999)

    bufsize=1024

    client_handler(ip_port,bufsize)

 

 

 

#_*_coding:utf-8_*_

__author__ = ‘Linhaifeng‘

from socket import *

import hmac,os

 

secret_key=b‘linhaifeng bang bang bang1111‘

def conn_auth(conn):

    ‘‘‘

    验证客户端到服务器的链接

    :param conn:

    :return:

    ‘‘‘

    msg=conn.recv(32)

    h=hmac.new(secret_key,msg)

    digest=h.digest()

    conn.sendall(digest)

 

def client_handler(ip_port,bufsize=1024):

    tcp_socket_client=socket(AF_INET,SOCK_STREAM)

    tcp_socket_client.connect(ip_port)

 

    conn_auth(tcp_socket_client)

 

    while True:

        data=input(‘>>: ‘).strip()

        if not data:continue

        if data == ‘quit‘:break

 

        tcp_socket_client.sendall(data.encode(‘utf-8‘))

        respone=tcp_socket_client.recv(bufsize)

        print(respone.decode(‘utf-8‘))

    tcp_socket_client.close()

 

if __name__ == ‘__main__‘:

    ip_port=(‘127.0.0.1‘,9999)

    bufsize=1024

    client_handler(ip_port,bufsize)