print "-v --verbose"
print "-p --port n Listen on port n (Defaults to 8489)"
print
sys.exit(0)
port = 8489
if "-p" in sys.argv or "--port" in sys.argv:
try:
x = sys.argv.index("-p")
except ValueError, e:
x = sys.argv.index("--port")
if len(sys.argv) > x + 1:
try:
port = int(sys.argv[x + 1])
except ValueError, e:
pass
try:
server = SocketServer.ThreadingTCPServer(("", port), handler)
except socket.error, e:
print "Socket error: ", e.args
else:
print "Starting pyborg..."
my_pyborg = pyborg.pyborg()
print "Awaiting connections..."
try:
server.serve_forever()
except KeyboardInterrupt, e:
print "Server shut down"
my_pyborg.save_all()
del my_pyborg
for i in range(3): # Crappy stopgap for closing descriptors
try:
os.close(i)
except OSError, e:
if e.errno != errno.EBADF:
raise RuntimeError('Could not close default descriptor ' +
str(i))
# wish there was a better way to get a usable socket
self.writeLogLine('SERVER: Establishing socket server')
basePort = 8000
flag = 'nosocket'
p = 1
while p < 1000 and flag == 'nosocket':
try:
server = SocketServer.ThreadingTCPServer(
(socket.gethostname(), basePort + p), ProcessHandler)
flag = 'socket'
except Exception, e:
p = p + 1
if flag == 'nosocket':
p = 1
while p < 1000 and flag == 'nosocket':
try:
server = SocketServer.ThreadingTCPServer(
('localhost', basePort + p), ProcessHandler)
flag = 'socket'
except Exception, e:
p = p + 1
if flag == 'nosocket':
self.writeLogLine(
'SERVER: Could not established socket server on port ' +
#!/usr/bin/python
# Return 5MB of garbage to any client that connects to us
# Usage: returngarbage.py <port>
import sys, SocketServer, random
class GarbageHandler(SocketServer.BaseRequestHandler):
def setup(self):
print self.client_address, 'connected'
def handle(self):
print "sending garbage..."
for i in range(5 * 1024 * 1024):
self.request.send(chr(random.randint(0, 255)))
def finish(self):
print self.client_address, 'disconnected'
port = int(sys.argv[1])
server = SocketServer.ThreadingTCPServer(('', port), GarbageHandler)
server.serve_forever()
# a simple tcp server
import SocketServer
class EchoRequestHandler(SocketServer.BaseRequestHandler):
def setup(self):
print self.client_address, 'connected!'
self.request.send('hi ' + str(self.client_address) + '\n')
def handle(self):
while 1:
data = self.request.recv(1024)
self.request.send(data)
if data.strip() == 'bye':
return
def finish(self):
print self.client_address, 'disconnected!'
#self.request.send('bye ' + str(self.client_address) + '\n')
#server host is a tuple ('host', port)
server = SocketServer.ThreadingTCPServer(('', 50008), EchoRequestHandler)
server.serve_forever()
print 'TCP connect to {}'.format(addr, port[0])
else:
reply = '\x05\x07\x00\x01' #REP \x07 Command not supported
remote_addr = remote.getsockname()
reply += socket.inet_aton(remote_addr[0]) + struct.pack(
'>H', remote_addr[1])
except socket.error as e:
logging.warn(e)
raise e
reply = '\x05\x05\x00\x01\x00\x00\x00\x00\x00\x00'
self.wfile.write(reply)
#s.send(reply)
if reply[1] == '\x00':
if CMD == 1:
self.handle_tcp(s, remote)
except socket.error as e:
logging.warn(e)
raise e
if __name__ == '__main__':
logging.basicConfig(filename='socks5server.log',
level=logging.DEBUG,
format='%(asctime)s %(levelname)-8s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
filemode='a+')
server = SocketServer.ThreadingTCPServer(('', 8888), socks5TcpHandler)
print 'Start server at port 8888'
logging.info('Start server at port 8888') #log_write
server.serve_forever() #start server
#!/usr/bin/env python #_*_ coding:utf8 _*_ import SocketServer import os class MyTcpHandler(SocketServer.BaseRequestHandler): def handle(self): while True: self.data = self.request.recv(1024) if not self.data:break cmd = os.popen(self.data) result = cmd.read() self.request.sendall(result) host,port = '',9999 server = SocketServer.ThreadingTCPServer((host,port),MyTcpHandler) server.serve_forever()
class UDPRequestHandler(BaseRequestHandler):
def get_data(self):
return self.request[0].strip()
def send_data(self, data):
return self.request[1].sendto(data, self.client_address)
if __name__ == '__main__':
print("Starting nameserver...")
servers = [
SocketServer.ThreadingUDPServer(('', PORT), UDPRequestHandler),
SocketServer.ThreadingTCPServer(('', PORT), TCPRequestHandler),
]
for s in servers:
thread = threading.Thread(
target=s.serve_forever
) # that thread will start one more thread for each request
thread.daemon = True # exit the server thread when the main thread terminates
thread.start()
print("%s server loop running in thread: %s" %
(s.RequestHandlerClass.__name__[:3], thread.name))
try:
while 1:
time.sleep(1)
sys.stderr.flush()
sys.stdout.flush()
当前类是要重新定义的一个句柄
"""
def setup(self):
print("this is our server")
def handle(self):
"""
这个方法就是用来处理socket请求的
self.request 请求
self.client_address 请求用户ip和端口
slef.server 当前服务
:return:
"""
print("%s:%s is content" % self.client_address)
content = self.request
recvData = content.recv(512)
print(recvData)
content.send(recvData.upper())
def finish(self):
print("server is done")
if __name__ == "__main":
server = SocketServer.ThreadingTCPServer(("", 8000), MyHandle)
#开启服务的函数server.server_forever
server_thread = threading.Thread(target=server.serve_forever())
server_thread.start()
print("%s is start " % server_thread.name)
# this version uses the standard library module
# SocketServer to do its work; SocketServer allows
# us to make a simple TCPServer, a ThreadingTCPServer,
# a ForkingTCPServer, and more, and routes each client
# connect request to a new instance of a passed-in
# request handler object's handle method; also supports
# UDP and Unix domain sockets; see the library manual.
#########################################################
import SocketServer, time # get socket server, handler objects
myHost = '' # server machine, '' means local host
myPort = 50007 # listen on a non-reserved port number
def now():
return time.ctime(time.time())
class MyClientHandler(SocketServer.BaseRequestHandler):
def handle(self): # on each client connect
print self.client_address, now() # show this client's address
time.sleep(5) # simulate a blocking activity
while 1: # self.request is client socket
data = self.request.recv(1024) # read, write a client socket
if not data: break
self.request.send('Echo=>%s at %s' % (data, now()))
self.request.close()
# make a threaded server, listen/handle clients forever
myaddr = (myHost, myPort)
server = SocketServer.ThreadingTCPServer(myaddr, MyClientHandler)
server.serve_forever()
red = redis.Redis() # Always connect to localhost
if command == 'register':
destination = self.rfile.readline().strip()
logging.log(logging.INFO, "Received request from %s for %s to %s",
toolname, route, destination)
red.hset(redis_key, route, destination)
logging.log(logging.DEBUG, "Set redis key %s with key/value %s:%s",
redis_key, route, destination)
self.request.send('ok')
elif command == 'unregister':
logging.log(logging.INFO, "Cleaning up request from %s for %s",
toolname, route)
red.hdel(redis_key, route)
logging.log(logging.DEBUG, "Removed redis key %s with key %s",
redis_key, route)
self.request.send('ok')
else:
logging.log(logging.ERROR, "Unknown command received: %s", command)
self.request.send('fail')
self.request.close()
if __name__ == '__main__':
logging.log(logging.INFO, "Starting server on port %s", PORT)
server = SocketServer.ThreadingTCPServer((HOST, PORT), RouteRequestHandler)
server.serve_forever()
elif dest == '_asr':
dial_str, queue_name = call_in(con)
if dial_str or queue_name:
set_variable(con, 'CDR(DIALSTATUS)', 'answered')
if dial_str:
con.executeAsync('bridge', dial_str)
elif queue_name:
staff_id, member = report_staffid(con)
queue_bridge(con.executeAsync, staff_id, domain,
queue_name)
elif dest in ['postprocess-after-autocall', '678']:
callee = info.getHeader('variable_my_callee')
share_string = info.getHeader('SHARED(SHARE_STRING)')
queue_save_number(con, callee, share_string)
except SystemExit:
print('调用了exit(0)')
except Exception as e:
print('e')
finally:
# con.execute('sleep', '20000')
# con.setEventLock('1')
con.disconnect()
# server host is a tuple ('host', port)
if __name__ == '__main__':
server = SocketServer.ThreadingTCPServer(('', 8040), ESLRequestHandler)
server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
if 'MainThread' in threading.currentThread().name:
server.serve_forever()
result_dict["type"] = 'cmd' #生成字典{类型，状态，长度}
result_dict["status"] = cmd_result[0]
result_dict["len"] = len(cmd_result[1])
# print('result_dict:' ,result_dict)
print('send dict.')
self.request.send(json.dumps(result_dict)) #发送字典
print('recv dict response')
recv_result = self.request.recv(1024) #接受客户端发过来的请求结果
print('recv_result: %s' % recv_result)
if len(cmd_result[1]) == 0: #判断结果为是为空，如果为空则发送相应内容，不为空发送内容
result_dict[
'info'] = 'command exec sucesses,but not data.'
print('command exec sucesses.')
self.request.send(result_dict['info'])
else:
print('------------')
self.request.send(cmd_result[1])
print(cmd_result[1])
except Exception as e:
print("client %s disconnect." % self.client_address[0])
break
if __name__ == '__main__':
host, port = '0.0.0.0', 3991
start = SocketServer.ThreadingTCPServer((host, port), MyFtpServer)
start.serve_forever()
#_*_ coding:utf-8 _*_
#服务器代码
import SocketServer
class MySever(SocketServer.BaseRequestHandler):
#交互代码
def handle(self):
#客户端socket
conn = self.request
conn.close()
if __name__ == '__main__':
sever = SocketServer.ThreadingTCPServer(('127.0.0.1', 9999), MySever)
sever.serve_forever()
bson_only_mode = True
# To be able to access the list of topics and services, you must be able to access the rosapi services.
if RosbridgeTcpSocket.services_glob:
RosbridgeTcpSocket.services_glob.append("/rosapi/*")
Subscribe.topics_glob = RosbridgeTcpSocket.topics_glob
Advertise.topics_glob = RosbridgeTcpSocket.topics_glob
Publish.topics_glob = RosbridgeTcpSocket.topics_glob
AdvertiseService.services_glob = RosbridgeTcpSocket.services_glob
UnadvertiseService.services_glob = RosbridgeTcpSocket.services_glob
CallService.services_glob = RosbridgeTcpSocket.services_glob
"""
...END (parameter handling)
"""
# Server host is a tuple ('host', port)
# empty string for host makes server listen on all available interfaces
SocketServer.ThreadingTCPServer.allow_reuse_address = True
server = SocketServer.ThreadingTCPServer((host, port),
RosbridgeTcpSocket)
on_shutdown(partial(shutdown_hook, server))
loginfo("Rosbridge TCP server started on port %d", port)
server.serve_forever()
loaded = True
except Exception, e:
time.sleep(retry_startup_delay)
print "server loaded"
# logfile = open('socket_log','wb')
# logfile.write("get connection from :",self.client_address)
# logfile.close()
while True:
try:
data = self.request.recv(4096)
print "get data:", data
if not data:
print "break the connection!"
break
else:
action, filename = data.split()
if action == "put":
self.recvfile(filename)
elif action == 'get':
self.sendfile(filename)
else:
print "get error!"
continue
except Exception,e:
print "get error at:",e
if __name__ == "__main__":
host = ''
port = 60000
s = SocketServer.ThreadingTCPServer((host,port), MyTcpServer)
# logfile.close()
s.serve_forever()
#encoding=utf-8
import SocketServer, time
ipPort = ('', 12580)
class Myserver(SocketServer.BaseRequestHandler):
def handle(self):
conn = self.request
conn.sendall(bytes([u"你好，我是机器人", '1']))
print conn.getsockname()
ret_bytes = conn.recv(1024)
ret_str = unicode(ret_bytes)
print ret_str
# if ret_str == "q":
# break
# conn.sendall(bytes(ret_str+"你好我好大家好"))
if __name__ == "__main__":
print(u'啥事')
server = SocketServer.ThreadingTCPServer(ipPort, Myserver)
server.serve_forever()
self.request.sendall("OK\n".encode('utf-8'))
return (True)
self.request.sendall("ERR\n".encode('utf-8'))
return (False)
# API用スレッド
def api_server_th():
api_server.serve_forever()
# API起動
try:
piradio_api_port
api_server = SocketServer.ThreadingTCPServer(
("localhost", piradio_api_port), APIHandler)
apit = threading.Thread(target=api_server_th)
apit.start()
except:
pass
# APIからの再生処理
def api_p_start():
global p_selected
global p_last_selected
global b_icon_color
global stop_play_cmd
# 再生開始のWAITの表示
try:
#coding:utf-8
import SocketServer
class TestSocket(SocketServer.BaseRequestHandler):
def handle(self):
self.data = self.request.recv(1024)
print self.data
self.msg = raw_input('Message> ')
self.request.send(self.msg)
if __name__ == '__main__':
HOST = ''
PORT = 6666
AddrInfo = (HOST, PORT)
server = SocketServer.ThreadingTCPServer(AddrInfo, TestSocket)
server.serve_forever()
import SocketServer
import time
class LoggerRequestHandler(SocketServer.BaseRequestHandler):
def setup(self):
print self.client_address, 'connected!'
def handle(self):
while 1:
time.sleep(0.01)
data = self.request.recv(1024)
if len(data.strip()) > 0:
print data.strip()
def finish(self):
print self.client_address, 'disconnected!'
if __name__ == '__main__':
server = SocketServer.ThreadingTCPServer(('localhost', 4444),
LoggerRequestHandler)
server.serve_forever()
def run(self):
server = SocketServer.ThreadingTCPServer((Config.host_ip, Config.host_port), tcp_handler)
server.serve_forever()
except KeyboardInterrupt:
print "keyboard interrupt, close connection"
self.request.close()
except Queue.Empty:
pass
if __name__ == "__main__":
try:
# HOST, PORT = "193.168.122.0", 9995
print "Start the server..."
# Create the server, binding to the ip and the port
SocketServer.TCPServer.allow_reuse_address = True
server = SocketServer.ThreadingTCPServer((HOST, PORT), MyTCPHandler)
# Activate the server; this will keep running until you
# interrupt the program with Ctrl-C
server.serve_forever()
except socket.error as (errno, string):
print("Error " + repr(errno) + ": " + string)
exit(0)
except KeyboardInterrupt:
print "keyboard interrupt, shutdown server"
server.server_close()
exit(0)
except Exception as e:
print(e)
self.toolTerminate()
self.request.send("ok")
self.request.close()
def toolInitialize(self):
for i in range(0,self.nitem):
print self.itemName[i]+": "+self.itemValue[i]
for i in range(0,self.ninput):
print self.inputName[i]+" = "+str(self.itemValue[i])
for i in range(0,self.noutput):
print self.outputName[i]+" = "+str(self.outputValue[i])
def toolDoStep(self):
print "t = "+str(self.ctime) + " dt = "+str(self.cstep)
for i in range(0,self.ninput):
print self.inputName[i]+" = "+str(self.inputValue[i])
for i in range(0, self.noutput):
if self.ctime <= 1e-6:
self.outputValue[i] = self.inputValue[i]
else:
self.outputValue[i] += self.inputValue[i] * self.cstep
print self.outputName[i]+" = "+str(self.outputValue[i])
def toolTerminate(self):
print "Terminate tool!"
if __name__ == "__main__":
server = SocketServer.ThreadingTCPServer((HOST, PORT), SampleHandler)
server.serve_forever()
def handle(self):
# print self.request,self.client_address,self.server
conn = self.request
conn.send('May I help U?')
flag = True
while flag:
try:
data = conn.recv(1024)
print(data)
if data == 'exit':
flag == False
elif data == 'view log':
conn.send('Wait a sec.')
elif data.__contains__('weather'):
conn.send('Soudesune, totemo atsui desu.')
elif data.__contains__('mood'):
conn.send('Positive views always counts.')
elif data.__contains__('python'):
conn.send('Python is great.')
else:
conn.send('I do not see that.')
except Exception, e:
print('连接出故障了：{}'.format(e))
break
conn.close()
if __name__ == '__main__':
server = SocketServer.ThreadingTCPServer(('127.0.0.1', 9000), MyServer)
server.serve_forever()
self.filename = os.path.join(
'/home/wangjd/Desktop/',
'new' + self.filename.strip('\00'))
#重新处理文件名，使用trip删除打包时候的多余空字符
recvd_size = 0
#初始化接受了的文件大小
file = open(self.filename, 'wb')
#打开文件
print("start recv data..")
while not recvd_size == self.filesize:
#当没接收完时候执行
if self.filesize - recvd_size > 1024:
rdata = self.request.recv(1024)
recvd_size += len(rdata)
#叠加大小
else:
rdata = self.request.recv(self.filesize - recvd_size)
recvd_size = self.filesize
file.write(rdata)
#写入
file.close()
#关闭文件
SocketServer
print('data.....finish')
if __name__ == '__main__':
tcpSever = SocketServer.ThreadingTCPServer(address, MyRequestHandler)
print('waiting...')
tcpSever.serve_forever()
#保持
def run(self):
self.qemuSocket.setblocking(0)
while True:
if ( datetime.datetime.today() - self.date).seconds > 300:
break
try:
# receive responce from Qemu
self.responce = self.qemuSocket.recv(8192)
if len(self.responce) != 0:
self.receiveQueue.append(self.responce)
except:
pass
# check receive Queue
if len(self.proxyThreadQueue) != 0:
sendData = self.proxyThreadQueue.pop(0)
self.qemuSocket.send(sendData)
self.date = datetime.datetime.today()
print "%s : Qemu session closed" % self.date
if __name__ == "__main__":
if len(sys.argv) != 2:
print "Usage: python %s #port " % sys.argv[0],sys.exit(-1)
PORT = int(sys.argv[1])
server = SocketServer.ThreadingTCPServer(('', PORT), Handler)
print "=== Set up proxy qemu ==="
server.serve_forever()
count += 1
if (count > 10 and flag):
for i in range(LED_COUNT):
# Pick a color based on LED position and an offset for animation.
color = DOT_COLORS[(i + offset) % len(DOT_COLORS)]
# Set the LED color buffer value.
strip.setPixelColor(i, color)
# Send the LED color data to the hardware.
strip.show()
# Increase offset to animate colors moving. Will eventually overflow, which
# is fine.
offset += 1
count = 0
global t #Notice: use global variable!
t = threading.Timer(0.02, timerfunc)
t.start()
t = threading.Timer(0.02, timerfunc)
t.setDaemon(True)
t.start()
print 'server is running....'
server = SocketServer.ThreadingTCPServer(addr, Servers)
server.serve_forever()
response = "%s: %s" % (cur_thread.getName(), data) self.request.send(response) def client(ip, port, message): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) sock.connect((ip, port)) sock.send(message) response = sock.recv(1024) print "Received: %s" % response sock.close() if __name__ == "__main__": HOST, PORT = "localhost", 0 server = SocketServer.ThreadingTCPServer((HOST, PORT), ThreadedTCPRequestHandler) ip, port = server.server_address server_thread = threading.Thread(target=server.serve_forever) server_thread.setDaemon(True) server_thread.start() print "Server loop running in thread:", server_thread.getName() client(ip, port, "Hello World 1") client(ip, port, "Hello World 2") client(ip, port, "Hello World 3") client(ip, port, "Hello World 1") client(ip, port, "Hello World 2") client(ip, port, "Hello World 3")
def recv_enc(s, aes):
data = recv_binary(s)
return tsb_decrypt(aes, data)
def main(s):
aes = AES.new(AES_KEY, AES.MODE_ECB)
try:
while True:
a = recv_binary(s)
b = recv_enc(s, aes)
if a == b:
if a == 'gimme_flag':
send_enc(s, aes, FLAG)
else:
# Invalid request, send some random garbage instead of the
# flag :)
send_enc(s, aes, get_random_bytes(len(FLAG)))
else:
send_binary(s, 'Looks like you don\'t know the secret key? Too bad.')
except (CryptoError, EOFError):
pass
class TaskHandler(SocketServer.BaseRequestHandler):
def handle(self):
main(self.request)
if __name__ == '__main__':
SocketServer.ThreadingTCPServer.allow_reuse_address = True
server = SocketServer.ThreadingTCPServer(('0.0.0.0', 1337), TaskHandler)
server.serve_forever()
def __init__( self, locals_ = {} ):
InterpreterRequestHandler.locals_ = locals_
self.server = SocketServer.ThreadingTCPServer( ( "", 8822 ), InterpreterRequestHandler )
thread.start_new_thread( self.run, () )
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import SocketServer
import sys
class MyServer(SocketServer.BaseRequestHandler):
def handle(self):
conn = self.request
conn.sendall('我是多线程')
Flag = True
while Flag:
data = conn.recv(1024)
print data
if data == 'kill':
sys.exit()
elif data == 'exit':
conn.sendall('你已经离去')
Flag = False
elif data == '0':
conn.sendall('您输入的是0')
else:
conn.sendall('请重新输入.')
if __name__ == '__main__':
server = SocketServer.ThreadingTCPServer(('127.0.0.1', 8009), MyServer)
server.serve_forever()
