Enchufes entre computadoras

Question

Hasta ahora he podido encontrar un socket básico en python 3.2. El cliente envía algunos datos, una X y una coordenada Y, al servidor, y el servidor toma los datos y devuelve un mensaje de confirmación. Pero el problema que tengo es hacer que escuche entre computadoras. Mi servidor y cliente funcionan perfectamente cuando los ejecuto uno al lado del otro en la misma computadora, pero quiero que se conecten mientras se ejecutan en diferentes computadoras.

Tengo una computadora arriba, y una computadora en la planta baja, ambas usando la misma conexión inalámbrica a Internet. ¿Hay alguna manera de conectar mi servidor y mi cliente desde una de estas computadoras?

Ya he intentado cambiar la IP del servidor a la dirección IP de mi módem inalámbrico, pero eso no funcionó.

Aquí está mi código hasta ahora, la única diferencia es que cambié la dirección IP de nuevo a una dirección de bucle de retorno estándar, ya que acaba de cambiar a mi IP no funcionó:

Cliente:

import pygame, sys 
from socket import socket, AF_INET, SOCK_DGRAM 
from time import gmtime, strftime 
from pygame.locals import * 

SERVER_IP = '127.0.0.1' 
PORT_NUMBER = 5000 
SCREEN_X = 400 
SCREEN_Y = 400 
SIZE = 1024 
PIC_PATH = "picture/path/goes/here.bmp" 
print ("Test client sending packets to IP {0}, via port {1}\n".format(SERVER_IP, PORT_NUMBER)) 

mySocket = socket(AF_INET, SOCK_DGRAM) 
x = y = 0 
screen = pygame.display.set_mode((SCREEN_X, SCREEN_Y)) #Make the screen 
ending = False 
word = "True" 
clock = pygame.time.Clock() #tick-tock 
grid = pygame.image.load(PIC_PATH) #Load the sheet 
gridRect = grid.get_rect() 
screen.blit(grid, gridRect) 
pygame.display.flip() 
while ending==False: 
    for event in pygame.event.get(): 
     if event.type == KEYDOWN: # key down or up? 
      if event.key == K_RIGHT: x+=1 
      elif event.key == K_LEFT: x-=1 
      elif event.key == K_UP: y-=1 
      elif event.key == K_DOWN: y+=1 
      if event.key == K_ESCAPE: 
       ending=True # Time to leave 
       print("Stopped Early by user") 
    if ending==True: word="False" 
    localTime = strftime("%H:%M:%S", gmtime()) 
    mySocket.sendto(bytes(str(x), 'UTF-8') , (SERVER_IP, PORT_NUMBER)) 
    mySocket.sendto(bytes(str(y), 'UTF-8') , (SERVER_IP, PORT_NUMBER)) 
    mySocket.sendto(bytes(word, 'UTF-8') , (SERVER_IP, PORT_NUMBER)) 
    print ("Sending packet... " + localTime) 
    clock.tick(10) 
    try: 
     (data, addr) = mySocket.recvfrom(SIZE) 
     print ("Received packet from: " + str(addr)) 
     print ("Received: " + data.decode('UTF-8')) 
    except: ending=False 
    if ending==True: 
     pygame.quit() 
     sys.exit() 

servidor:

from socket import socket, gethostbyname, AF_INET, SOCK_DGRAM 
import sys 
PORT_NUMBER = 5000 
SIZE = 1024 

hostName = gethostbyname('localhost') 

mySocket = socket(AF_INET, SOCK_DGRAM) 
mySocket.bind((hostName, PORT_NUMBER)) 

print ("Test server listening on port {0}\n".format(PORT_NUMBER)) 

flag="True" 

while flag=="True": 
    #Show that data was received: 
    (data, addr) = mySocket.recvfrom(SIZE) 
    xer=data.decode('UTF-8') 
    print ("Received packet from: " + str(addr) + ", X value:" + str(xer)) 
    (data, addr) = mySocket.recvfrom(SIZE) 
    yer=data.decode('UTF-8') 
    print ("Received packet from: " + str(addr) + ", Y value:" + str(yer)) 
    #Check to see if the other program wants to close: 
    (flagger, addr) = mySocket.recvfrom(SIZE) 
    flag=flagger.decode('UTF-8') 
    #Send a message back to the client: 
    if flag=="False": s="Good-bye!" 
    else: s="Read you loud and clear" 
    mySocket.sendto(bytes(s, 'UTF-8') , (addr)) 
sys.exit() 

Sólo en caso de que se esté preguntando por qué el cliente es tan grande, es porque estoy tratando de hacer un pequeño juego en pygame que será multi-jugador. No internet pero LAN o inalámbrico entre mis dos computadoras. Soy muy nuevo en sockets y cosas relacionadas con la web (no sé si LAN es básicamente lo mismo que wireless o qué) así que cualquier ayuda sobre esto es muy apreciada. :)

Answer 1

No enlazar a localhost. Esto significa que su servidor solo se escuchará a sí mismo. Si se vincula al 0.0.0.0, esto asegurará que su servidor esté escuchando cada computadora que pueda alcanzarlo. (Advertencia: potencialmente inseguro)

Una regla de firewall excesivamente celosa también podría ser la culpable.

Asegúrese de que se está conectando a la IP de su servidor en la subred de su enrutador. Para hacerlo, ejecute ifconfig en Mac/Linux o ipconfig en Windows, lo que probablemente le muestre una IP de estilo 192.168.x.x (que no será la misma que la de su enrutador). También puede ver qué computadoras e IP están conectadas a su enrutador a través de su página administrativa.

En cualquier punto del tiempo, una computadora que está conectada a Internet tiene muchas direcciones IP. La dirección de bucle es solo 'visible' para su computadora. Una IP como 10.x.x.x o 192.168.x.x sería visible para cualquier computadora conectada a su enrutador. La mayoría de las otras IP son IP públicas.

Answer 2

Debe utilizar las direcciones IP de las computadoras en la red local. La dirección IP local debería ser algo así como:

| Device |  IP  | 
|:----------:|:-----------:| 
| router  | 192.168.1.1 | 
| computer_1 | 192.168.1.2 | 
| computer_2 | 192.168.1.3 |