We Keep Coding

Python multiclient server

I want to create a TCP server which can send specific messages to specific clients. In my example, I have two clients Iconet and Robot. I want to send specific messages to each of these clients once they are connected. I wish to send VITAi and VITAr to the clients respectively. Once i receive the response from the two clients i wish to jump to def chat() The aim is to get the response from clients and then jump to def chat() which acts like a chat room and displays the messages the clients have sent. How can i achieve this?
server
import threading
import socket
PORT = 1026
SERVER = socket.gethostbyname(socket.gethostname())
ADDR = (SERVER,PORT)
FORMAT = "utf-8"
HEADER = 1024
DISCONNECT_MESSAGE = "END_CYCLE"
VITA_R = "yes"
VITA_I = "yes"
robot_flag = False
iconet_flag = False
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(ADDR)
clients = []
aliases = []
alias_dictionary_iter = zip(aliases,clients)
alias_dictionary = dict(alias_dictionary_iter)
def broadcast(broadcast_message):
for client in clients:
client.send(broadcast_message)
def handle_client(client,addr):
print(f"[NEW CONNECTION] {addr} connected.")
connected = True
while connected:
for client in clients:
if client == clients[0]:
robot_message = 'VITAr'
client.send(robot_message.encode(FORMAT))
robot_response = client.recv(2048).decode(FORMAT)
print(robot_response)
if robot_response == VITA_R:
robot_flag == True
else:
robot_flag == False
elif client == clients[1]:
iconet_message = 'VITAi'
client.send(iconet_message.encode(FORMAT))
iconet_response = client.recv(2048).decode(FORMAT)
print(iconet_response)
if iconet_response == VITA_I:
iconet_flag == True
else:
iconet_flag == False
def chat(client):
while robot_flag & iconet_flag == True:
try:
message = client.recv(1024)
broadcast(message)
print(message)
except:
index = clients.index(client)
clients.remove(client)
client.close()
alias = aliases[index]
broadcast(f'{alias} has left the chat room!'.encode('utf-8'))
aliases.remove(alias)
break
def start():
server.listen()
print(f"[LISTENING] Server is listening on {SERVER}")
while True:
client, addr = server.accept()
print(f"[NEW CONNECTION] {addr} connected.")
client.send('NAME?'.encode(FORMAT))
alias = client.recv(1024)
aliases.append(alias)
clients.append(client)
print(f'The clients is {alias}'.encode(FORMAT))
thread = threading.Thread(target= handle_client, args=(client, addr))
thread.start()
print ('[STARTING] server is starting')
start()
client
import threading
import socket
name = input('NAME? ')
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('0.0.0.0', 1026))
def client_receive():
while True:
try:
message = client.recv(1024).decode('utf-8')
if message == "NAME?":
client.send(name.encode('utf-8'))
else:
print(message)
except:
print('Error!')
client.close()
break
def client_send():
while True:
message = f'{name}: {input("")}'
client.send(message.encode('utf-8'))
receive_thread = threading.Thread(target=client_receive)
receive_thread.start()
send_thread = threading.Thread(target=client_send)
send_thread.start()

I need client side to write to the server side

I'm trying to make the clients be able to send messages to the server, right now clients can only send messages to each other, I have added the line where datafromclient but it only receives the first input by the client, after that only the clients exchange messages.
here is my code for server.py
import socket
import threading
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((socket.gethostname(),1234))
s.listen()
print("Waiting for connections")
clients = []
unames = []
def broadcast(message):
for client in clients:
client.send(message)
def handle(client):
while True:
try:
message = client.recv(1024)
broadcast(message)
except:
index = clients.index(client)
clients.remove(client)
client.close()
uname = unames[index]
broadcast(f"{uname} left the server!".encode("utf-8"))
unames.remove(uname)
break
def receive():
while True:
client, addr = s.accept()
print(f"Connected with {str(addr)}")
client.send('uname'.encode("utf-8"))
uname = client.recv(1024).decode("utf-8")
unames.append(uname)
clients.append(client)
broadcast(f"{uname} joined the server!".encode("utf-8"))
client.send("\nWelcome to the server!".encode("utf-8"))
fOpen = open("rules.txt", "r")
client.send(fOpen.read().encode("utf-8"))
datafromclient = client.recv(1024)
print(datafromclient.decode("utf-8"))
thread = threading.Thread(target=handle, args=(client,))
thread.start()
receive()
s.close()
And this is client.py
import socket
import threading
c = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
c.connect((socket.gethostname(),1234))
uname = input("Username: ")
def receive():
while True:
try:
message = c.recv(1024).decode("utf-8")
if message == "uname":
c.send(uname.encode("utf-8"))
else:
print(message)
except:
print("An error occurred!")
c.close()
break
def write():
while True:
message = f'{uname}: {input("")}'
c.sendall(message.encode("utf-8"))
recv_thread = threading.Thread(target=receive)
recv_thread.start()
write_thread = threading.Thread(target=write)
write_thread.start()

This should give you an idea:
server.py:
import socket
import threading
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((socket.gethostbyname(socket.gethostname()), 1234))
clients = []
def handle_client(conn, addr):
clients.append(conn)
while True:
msg_length = conn.recv(64).decode("utf-8")
if msg_length:
msg = conn.recv(int(msg_length)).decode("utf-8")
print(msg)
if msg == "!DISCONNECT":
break
for client in clients:
client.send(msg.encode("utf-8"))
clients.remove(conn)
conn.send('Bye'.encode("utf-8"))
conn.close()
server.listen()
while True:
conn, addr = server.accept()
thread = threading.Thread(target=handle_client, args=(conn, addr))
thread.start()
client.py:
import socket
import threading
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((socket.gethostbyname(socket.gethostname()), 1234))
def send():
msg = input(">>> ")
client.send(str(len(msg)).encode("utf-8").ljust(64))
client.send(msg.encode("utf-8"))
thread = threading.Thread(target=send)
thread.start()
while True:
if client.recv(2048).decode("utf-8") == "Bye":
break
thread = threading.Thread(target=send)
thread.start()

Connect sql server to Python3 - client-server

i'm new in socket programming with python i wrote some code for client and server that is not completed.
i want to connect my server side to Sql server dbms to store data there (this is a student management system) i want to send some data from client side then server side store them on data base and when got asked by client return them.
Here is my both side codes:
this is client:
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host ="127.0.0.1"
port =8000
def send(message):
message=str(message)
s.send(message.encode())
data = s.recv(1024).decode()
print (data)
def end():
s.close ()
def menu1():
print("Data has been saved to DB!\nWhat you need next?\n1.Close Connection.\n2.Enter More Data.\n3.Get Data.")
while 1:
m=input()
if int(m)==1:
end()
elif int(m)==2:
enter_data()
elif int(m)==3:
get_data()
else:
print("Choose a Num between 1-3!\n")
def enter_data():
flag=0
while 1:
if flag==0:
r = input('enter amount of student: ')
for i in range (0,int(r)):
name=input("Enter Student %d name"%(i))
send(name)
break
menu1()
def start():
s.connect((host,port))
print("You are connected to server!")
print("1.Enter Data")
print("2.Get Data")
m=input()
if int(m)==1:
enter_data()
elif int(m)==2:
end()
def menu():
m = input("press any key to connect!\n");
start()
if __name__ == "__main__":
menu()
and this is server side code:
import socket
from threading import *
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = ""
port = 8000
#print (host)
#print (port)
serversocket.bind((host, port))
class client(Thread):
def __init__(self, socket, address):
Thread.__init__(self)
self.sock = socket
self.addr = address
self.start()
def run(self):
#amount=self.sock.recv(1024).decode()
#amount=int(amount)
#counter=0
while 1:
api=self.sock.recv(1024).decode()
#print(self.sock.recv(1024).decode())
print("Client sent some messages: %s"%(api))
#api=self.sock.recv(1024).decode()
if str(api)=="avarage":
avarage=2/10
c=str(avarage)
self.sock.send(c.encode())
else:
avarage = 3 / 10
c = str(avarage)
self.sock.send(c.encode())
serversocket.listen(5)
print ("server started and listening to port:%s"%(port))
while 1:
clientsocket, address = serversocket.accept()
client(clientsocket, address)
I'm a bit new in this type of programming so please give me a part of code that i need to add.
thanks in advance.

I know that some parts of this code is not usable i just wrote them for test some things and get the concept of that.
also when i want to close connection server side i got this error:
File "C:/Users/name/PycharmProjects/Socket/venv/Socket1.py", line 23, in run
api=self.sock.recv(1024).decode()
ConnectionAbortedError: [WinError 10053] An established connection was aborted by the software in your host machine

What is the problem with the following python socket server code?

Why is it that the following server code cannot seem to accept new connections with clients even after the first connection is closed?
def bindPort(port):
global return_response
serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
serverSocket.bind(('', port))
except:
print("Cannot bind to port. Error: " + str(sys.exc_info))
serverSocket.listen(2)
print("The server is ready to receive")
count = 0
while True:
connectionSocket, addr = serverSocket.accept()
count += 1
print("Accepted {} connections so far.".format(count))
print('Connection established from {}'.format(addr))
while True:
sentence = connectionSocket.recv(1024)
if not sentence:
print("Empty")
break
print(sentence)
#parseIncomingRequest(sentence.decode())
print(return_response)
connectionSocket.send(return_response.encode())
return_response = ''
print("Closing loop")
connectionSocket.close()

I apologize for not reading the question properly
1)declare the return response variable before you use it
2)break out of the second while loop if you want accept an other connection .In the question you said that no connections were being accepted after the socket was closed but for the socket to close you have to break out out of the second while loop.or in my opinion you should remove the second loop .
3)if you want to keep listening on the socket and still be able to receive other connections use the threading module
def bindPort(port):
global return_response
serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
serverSocket.bind(('', port))
except:
print("Cannot bind to port. Error: " + str(sys.exc_info))
serverSocket.listen(2)
print("The server is ready to receive")
count = 0
while True:
connectionSocket, addr = serverSocket.accept()
count += 1
print("Accepted {} connections so far.".format(count))
print('Connection established from {}'.format(addr))
sentence = connectionSocket.recv(1024)
if not sentence:
print("Empty")
break
print(sentence)
#parseIncomingRequest(sentence.decode())
return_response = ''
print(return_response)
connectionSocket.send(return_response.encode())
connectionSocket.shutdown(socket.SHUT_RDWR)
connectionSocket.close()
4)or if you want to keep the loop for further modfication
import socket
def bindPort(port):
global return_response
serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
serverSocket.bind(('', port))
except:
print("Cannot bind to port. Error: " + str(sys.exc_info))
serverSocket.listen(2)
print("The server is ready to receive")
count = 0
while True:
connectionSocket, addr = serverSocket.accept()
count += 1
print("Accepted {} connections so far.".format(count))
print('Connection established from {}'.format(addr))
while True:
sentence = connectionSocket.recv(1024)
if not sentence:
print("Empty")
break
print(sentence)
#parseIncomingRequest(sentence.decode())
return_response = 'a'
print(return_response)
connectionSocket.send(return_response.encode())
break
print("Closing loop")
connectionSocket.shutdown(socket.SHUT_RDWR)
connectionSocket.close()

Client doesn't connect to server from different computer on the INTERNET

I have been working on a very simple group chat program. The program works well when tested on the same computer, but doesn't work between different computers on the INTERNET.
I have tried disabling Windows Fire Wall.
I cannot narrow down the code, Sorry.
The program uses a socket and Threading library.
Client Code:
import socket
import threading
SERVER_IP = "127.0.0.1" #This is changed to the servers PUBLIC IP when testing with another computer.
SERVER_PORT = 9279
global name
global sock
def connect():
global sock
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_addres = (SERVER_IP, SERVER_PORT)
try:
sock.connect(server_addres)
print("Connected.")
return 1
except:
print("Cant connect to server.")
return 0
def send_msg():
global sock
while True:
try:
msg = name + " >> " + input()
sock.sendall(msg.encode())
except Exception as e:
print(e)
def recieve_msg():
global sock
server_active = 1
while True and server_active:
try:
recieved_msg = sock.recv(1024).decode()
print("\n" + recieved_msg)
except Exception as e:
print(e)
server_active = 0
def main():
global name
name = input("Enter name: ")
connected = connect()
while True and connected:
send_thread = threading.Thread(target=send_msg)
send_thread.start()
recv_thread = threading.Thread(target=recieve_msg)
recv_thread.start()
while recv_thread.is_alive():
recv_thread.join(timeout=0.1)
sock.close()
Server code:
import socket
import _thread
host = "My private IP"
port = 9279
global thread_active
thread_active = 1
global client_list
client_list = []
global addr
def on_new_client(clientsocket, pt):
global thread_active
global client_list
while True and thread_active:
global addr
try:
msg = clientsocket.recv(1024).decode()
print(msg + " " + str(addr))
for client in client_list:
client.send(msg.encode())
except Exception as e:
print("Client " + str(addr[0]) + ':' + str(addr[1]) + " disconnected (" + str(e) + ")")
if clientsocket in client_list:
client_list.remove(clientsocket)
print(client_list)
thread_active = 0
s = socket.socket()
print('Server started!')
print('Waiting for clients...')
s.bind((host, port)) # Bind to the port
s.listen(10) # Now wait for client connection.
while True:
c, addr = s.accept()
print('Got connection from', addr)
client_list.append(c)
_thread.start_new_thread(on_new_client, (c, 0))
thread_active = 1
s.close()
clientsocket.close()