[ADMIN][RCON] mcrcon, client de connexion à distance pour les serveurs minecraft – Resoudre les problemes d’un serveur MineCraft

Code:

/ *
* Copyright (c) 2012, Tiiffi 
*
* Ce logiciel est fourni «en l’état», sans mention expresse ou implicite.
* garantie. En aucun cas, les auteurs ne pourront être tenus responsables de dommages et intérêts
* découlant de l'utilisation de ce logiciel.
*
* La permission est accordée à quiconque d’utiliser ce logiciel à quelque fin que ce soit,
* y compris les applications commerciales, et de le modifier et de le redistribuer
* librement, sous réserve des restrictions suivantes:
*
* 1. L'origine de ce logiciel ne doit pas être déformée; il ne faut pas
* prétendre que vous avez écrit le logiciel original. Si vous utilisez ce logiciel
* dans un produit, un accusé de réception dans la documentation du produit serait
* apprécié mais n'est pas obligatoire.
*
* 2. Les versions sources modifiées doivent être clairement indiquées comme telles et ne doivent pas être modifiées.
* dénaturé comme étant le logiciel d'origine.
*
* 3. Cet avis ne peut être enlevé ou modifié d'aucune source
*  Distribution.
* /
 
/ *
* Nom: mcrcon (minecraft rcon)
*
* Licence: Licence zlib / libpng
*
*
* Contact:
* WWW: http://sourceforge.net/projects/mcrcon/
* MAIL: tiiffi_at_gmail_dot_com
* IRC: tiiffi @ quakenet
*
*
* La description:
* Mcrcon est un client / terminal minecraft rcon puissant avec prise en charge de la coloration bukkit.
* Il est bien adapté à l'administration à distance et à être utilisé dans le cadre de scripts de maintenance de serveur automatisée.
* Ne provoque pas de spam "IO: canal cassé" ou "IO: Connection reset" dans la console du serveur.
*
*
* Caractéristiques:
* - Mode terminal interactif. Maintient la connexion en vie.
* - Envoyer plusieurs commandes dans une ligne de commande.
*  - Mode silencieux. N'imprime pas la sortie rcon.
* - Prise en charge de la coloration bukkit sous Windows et Linux (shells compatibles sh).
* - Code multiplateforme. Compile sur de nombreuses plates-formes avec des modifications mineures.
*
*
* Historique de la version:
*
* 0.0.5
* - Le programme utilise la fonctionnalité C99 (tableaux de longueur variable), donc l'indicateur "-std = gnu99" est activé
* GCC-compiler doit être utilisé pour éviter les avertissements inutiles.
*
* - Le tampon de réception Rcon est maintenant plus grand (2024 octets -> 10240 octets).
* * Merci aux forums 'gman_ftw' @ Bukkit.
*
* - Correction du message d'erreur invalide lors de la réception d'un paquet rcon vide (10 octets).
* * Merci aux forums 'pkmnfrk' @ bukkit.
*
* - Le mode terminal se ferme maintenant automatiquement lorsque rcon socket est fermé par le serveur
* ou si la taille du paquet ne peut pas être récupérée correctement.
*
* - Le client essaie maintenant de nettoyer les données du socket entrant si le dernier paquet était hors spécifications.
*
*
* 0.0.4
* - Revient au gestionnaire d'erreur des options getopts par défaut (opterr = 1).
* Le gestionnaire d'erreurs personnalisé nécessite une réécriture.
* - Quelques corrections utiles dans les chaînes de sortie du programme.
* - Utilisation du programme (); La fonction attend maintenant d’entrer avant de quitter Windows.
*
*
* 0.0.3
* - Les couleurs sont maintenant supportées sur Windows aussi!
* - Le mode terminal est maintenant déclenché avec l'indicateur "-t". Le drapeau "-i" fonctionne toujours pour
*    rétrocompatibilité.
* - Corrections de bugs (vérification de la taille des paquets évaluant toujours la validité des faux et des couleurs)
* cocher toujours évaluer vrai).
*
*
* 0.0.2
* - La licence est passée de 'Licence ISC' à 'Licence zlib / libpng'.
* - Corrections de bugs et nettoyage de code
* - Mode interactif (drapeau -i). Le client agit comme un terminal interactif.
* - La valeur de retour du programme est maintenant le nombre de commandes rcon envoyées avec succès.
* Si la connexion ou l'authentification échoue, la valeur de retour est -1.
* - Les couleurs sont maintenant activées par défaut. Désormais, l'indicateur -c désactive le support des couleurs.
*
*
* 0.0.1
* - Ajout du support expérimental pour les couleurs de bukkit.
* Devrait fonctionner avec n'importe quel shell compatible sh.
* - Les données de chaîne de paquets sont limitées à 2048 octets maximum (DATA_BUFFSIZE).
* Aucune idée de la façon dont Minecraft gère plusieurs paquets rcon.
* Si quelqu'un le sait, envoyez-moi un mail afin que je puisse le mettre en œuvre.
*
*
* FAIRE:
* - Rendre le tampon de réception dynamique
* - Changer certains problèmes de taille de paquet en erreurs fatales
* - Nettoyage du code
* - Vérifier les variables globales (à supprimer si possible)
* - Ajoute quelques vérifications de protocole
* - Nettoyage du préprocesseur (#ifdef / #ifndef)
* - Suivre le protocole standard de valve rcon?
* - Support de paquets multiples si Minecraft le supporte?!
* - Recherchez si les messages de discussion du joueur sont envoyés via rcon.
* S'ils le sont, le système de messagerie nécessite une réécriture.
*
*
* Rapports de bugs et demandes de fonctionnalités à tiiffi_at_gmail_dot_com.
*
* /
 
 
#comprendre 
#comprendre 
#comprendre 
#comprendre 
#comprendre 
 
#ifdef _WIN32
    / * pour la résolution de noms sous windows * /
    #define _WIN32_WINNT 0x0501
 
    #comprendre 
    #comprendre 
    #comprendre 
#autre
    #comprendre 
    #comprendre 
    #comprendre 
    #comprendre 
    #comprendre 
#fin si
 
/ * macro valeur absolue
#define absolute (x) (x <0)? (0 - x): x
* /
 
#define RCON_EXEC_COMMAND 2
#define RCON_AUTHENTICATE 3
#define RCON_RESPONSEVALUE 0
#define RCON_AUTH_RESPONSE 2
#define RCON_PID 42
 
/ * Valeur sûre je pense. Cela devrait me rendre dynamique pour des performances plus stables! * /
#define DATA_BUFFSIZE 10240
 
#define VERSION "0.0.5"
#define IN_NAME "mcrcon"
#define VER_STR IN_NAME "" VERSION
 
/ * structure de paquets rcon * /
typedef struct _rc_packet 
    taille int;
    int id;
    int cmd;
    données de char[DATA_BUFFSIZE];
    / * ignorant string2 atm .. * /
 rc_packet;
 
/* les fonctions */
 
erreur vide (char * errstring);
#ifndef _WIN32
void print_color (int color);
#fin si
 
struct in_addr net_resolve (char * host);
void net_close_socket (int sd);
int net_open_socket (char * host, int port);
int net_send_packet (int sd, rc_packet * packet);
rc_packet * net_recv_packet (int sd);
#ifdef _WIN32
void net_init_WSA (void);
#fin si
int net_clean_incoming (int sd, taille int);
 
rc_packet * packet_build (int id, int cmd, char * s1);
void packet_print (rc_packet * packet);
 
int rcon_auth (int rsock, char * passwd);
int rcon_command (int rsock, char * command);
 
int get_line (char * buffer, int len);
int run_terminal_mode (int rsock);
int run_commands (int argc, char * argv[])
 
 
/ * des globals * /
int silent_mode = 0;
int print_colors = 1;
int connection_alive = 1;
chaussette; / * prise rcon * /
 
#ifdef _WIN32
  / * console à colorier sous windows * /
  HANDLE console_handle;
#fin si
 
/ * trucs de sécurité (les fenêtres fonctionnent toujours mal) * /
void exit_proc (void) 
    if (rsock! = -1) net_close_socket (rsock);

 
/ * Vérifiez le comportement de windows et linux !!! * /
void sighandler (int sig) 
    connexion_alive = 0;
    #ifndef _WIN32
      sortie (-1);
    #fin si

 
int principal (int argc, char * argv[])

    int opt, ret = 0;
    int terminal_mode = 1;
 
    char * host = "192.168.1.3";
    char * pass = "123456";
    int port = 25575;
 
 
 
    opterr = 1; / * gestionnaire d'erreurs par défaut activé * /
    while ((opt = getopt (argc, argv, "tcshH: p: p: i"))!! = -1)
    
        commutateur (opt)
        
            cas 'H': hôte = optarg; Pause;
            cas 'P': port = atoi (optarg); Pause;
            cas 'p': pass = optarg; Pause;
            cas 'C':
            case 'c': print_colors = 0; Pause;
            cas 's':
            case 's': silent_mode = 1; Pause;
            cas 'T':
            cas 't':
            cas 'je':
            case 'i': terminal_mode = 1; Pause;
            cas 'h':
            Cas '?':
                / *
                if (optopt == 'P' 
    
 
    if (hôte == NULL) 
        fputs ("Hôte non défini. Indicateur de vérification -H.  n  n", stdout);
 
    
 
    si (port <= 0) 
        fputs("Invalid port. Check -P flag.nn", stdout);
 
    
 
    if(optind == argc && terminal_mode == 0) 
        fputs("No commands specified.nn", stdout);
   
    
 
    /* safety features to prevent "IO: Connection reset" bug on the server side */
    atexit(&exit_proc);
    signal(SIGABRT, &sighandler);
    signal(SIGTERM, &sighandler);
    signal(SIGINT, &sighandler);
 
    #ifdef _WIN32
      net_init_WSA();
      console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
      if(console_handle == INVALID_HANDLE_VALUE) console_handle = NULL;
    #endif
 
    /* open socket */
    rsock = net_open_socket(host, port);
 
    /* auth & commands */
    if(rcon_auth(rsock, pass))
    
        if(terminal_mode)
            ret = run_terminal_mode(rsock);
        else
            ret = run_commands(argc, argv);
    
    else /* auth failed */
    
        ret = -1;
        fprintf(stdout, "Authentication failed!n");
    
 
    /* cleanup */
    net_close_socket(rsock);
    rsock = -1;
 
    return ret;

 
void usage(void)

    fputs(
        "Usage: "IN_NAME" [OPTIONS]... [COMMANDS]...n"
        "Sends rcon commands to minecraft server.nn"
        "Option:n"
        "  -httPrints usage.n"
        "  -sttSilent mode. Do not print data received from rcon.n"
        "  -tttTerminal mode. Acts as interactive terminal.n"
        "  -pttRcon password. Default: "".n"
        "  -HttHost address or ip.n"
        "  -PttPort. Default: 25575.n"
        "  -cttDo not print colors. Disables bukkit color printing.n"
    ,stdout);
 
    puts("nInvidual commands must be separated with spaces.n");
    puts("Example:n  "IN_NAME" -c -H 192.168.1.42 -P 9999 -p password cmd1 "cmd2 with spaces"n");
    puts("minecraft rcon ("IN_NAME") "VERSION".nReport bugs to tiiffi_at_gmail_dot_com.n");
 
    #ifdef _WIN32
      puts("Press enter to exit.");
      getchar();
    #endif
    exit(0);

 
void error(char *errstring)

    fputs(errstring, stderr);
    exit(-1);

 
#ifdef _WIN32
void net_init_WSA(void)

    WSADATA wsadata;
    int err;
 
    err = WSAStartup(MAKEWORD(1, 1), &wsadata);
    if(err != 0)
    
        fprintf(stderr, "WSAStartup failed. Errno: %d.n", err);
        exit(-1);
    

#endif
 
struct in_addr net_resolve(char *host)

    struct in_addr address;
 
    struct sockaddr_in *sockaddr_ipv4;
    struct addrinfo hints, *result;
    int ret;
 
    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;
 
    ret = getaddrinfo(host, NULL, &hints, &result);
    if(ret != 0)
    
        fprintf(stderr, "Error: Unable to resolve hostname (%s).n", host);
        exit(-1);
    
 
    sockaddr_ipv4 = (struct sockaddr_in *) result->ai_addr;
 
    adresse = sockaddr_ipv4-> sin_addr;
 
    freeaddrinfo (résultat);
 
    adresse de retour;

 
/ * socket close and cleanup * /
void net_close_socket (int sd)

    #ifdef _WIN32
        closesocket (sd);
        WSACleanup ();
    #autre
        fermer (sd);
    #fin si

 
/ * Ouvre et connecte prise * /
int net_open_socket (char * host, int port)

    int sd;
    struct sockaddr_in sa;
 
    memset (& sa, 0, sizeof (sa)); / * Définit la structure pleine de zéros. * /
    sa.sin_family = AF_INET; / * Adresse Famille Inet = Protocole Famille Inet. * /
    sa.sin_port = htons (port); /* Numéro de port. * /
    sa.sin_addr = net_resolve (hôte); / * résolvez l'hôte. * /
 
    if ((sd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP))) < 0)
    
        #ifdef _WIN32
            WSACleanup();
        #endif
        error("Error: cannot create socket.n");
    
 
    if(connect(sd, (struct sockaddr *)&sa, sizeof(sa)) != 0)
    
        net_close_socket(sd);
        fprintf(stderr, "Error: connection failed (%s).n", host);
        exit(-1);
    
 
    return sd;

 
int net_send_packet(int sd, rc_packet *packet)

    int len;
    int total = 0;        /* how many bytes we've sent */
    int bytesleft;        /* how many we have left to send */
    int ret = -1;
 
    bytesleft = len = packet->taille + taillede (int);
 
    tandis que (total <len)
    
        ret = send (sd, (char *) packet + total, bytesleft, 0);
        if (ret == -1) break; 
        total + = ret;
        bytesleft - = ret;
    
 
    / * retourne -1 en cas d'échec, 0 en cas de succès * /
    Retourner Ret == -1? -1: 1;

 
rc_packet * net_recv_packet (int sd)

 
int net_clean_incoming (int sd, int size)

    char tmp[size];
 
    int ret = recv (sd, tmp, taille, 0);
 
    si (ret == 0) 
        fprintf (stderr, "Connexion perdue.  n");
        connexion_alive = 0;
    
 
    retour ret;

 
void print_color (int color)

    / * palette de couleurs compatible sh * /
    #ifndef _WIN32
    char * couleurs[] = 
        " 033[0; 30m ", / * 00 BLACK 0x30 * /
        " 033[0; 34m ", / * 01 BLEU 0x31 * /
        " 033[0; 32m ", / * 02 GREEN 0x32 * /
        " 033[0; 36m ", / * 03 CYAN 0x33 * /
        " 033[0; 31m ", / * 04 RED 0x34 * /
        " 033[0; 35m ", / * 05 PURPLE 0x35 * /
        " 033[0; 33m ", / * 06 GOLD 0x36 * /
        " 033[0; 37m ", / * 07 GREY 0x37 * /
        " 033[1; 30m ", / * 08 DGREY 0x38 * /
        " 033[1; 34m ", / * 09 LBLUE 0x39 * /
        " 033[1; 32m ", / * 10 LGREEN 0x61 * /
        " 033[1; 36m ", / * 11 LCYAN 0x62 * /
        " 033[1; 31m ", / * 12 LRED 0x63 * /
        " 033[1; 35m ", / * 13 LPURPLE 0x64 * /
        " 033[1; 33m ", / * 14 JAUNE 0x65 * /
        " 033[1; 37m ", / * 15 BLANC 0x66 * /
    ;
 
    si (couleur == 0) 
        fputs (" 033[0m ", stdout); / * ANNULER COULEUR * /
    
    autre
    #fin si
    
        si (couleur> = 0x61 && couleur <= 0x66) color -= 0x57;
        else if(color >= 0x30 && couleur <= 0x39) color -= 0x30;
        else return;
 
        #ifndef _WIN32
          fputs(colors[color], stdout);
        #else
          SetConsoleTextAttribute(console_handle, color);
        #endif
    

 
/* this hacky mess might use some optmizing */
void packet_print(rc_packet *packet)

    int i;
    int def_color = 0;
 
    #ifdef _WIN32
      CONSOLE_SCREEN_BUFFER_INFO console_info;
      if(GetConsoleScreenBufferInfo(console_handle, &console_info) != 0)
          def_color = console_info.wAttributes + 0x30;
      else def_color = 0x37;
    #endif
 
    /* colors enabled so try to handle the bukkit colors for terminal */
    if(print_colors == 1) 
 
        for(i = 0; (unsigned char) packet->Les données[i] ! = 0; ++ i) 
            if ((unsigned char) packet -> data[i] == 0xa7) 
                ++ i;
                print_color (paquet-> données[i])
                continuer;
            
            si (paquet-> données[i] == 0x0A) print_color (def_color);
 
            putchar (paquet-> données[i])
        
        print_color (def_color); / * annuler la coloration * /
 
    
    / * couleurs de bande * /
    autre
    
        pour (i = 0; (unsigned char)) paquet-> données[i] ! = 0; ++ i) 
            if ((unsigned char) packet -> data[i] == 0xa7) 
                ++ i;
                continuer;
            
            putchar (paquet-> données[i])
        
    
 
    / * Affiche une nouvelle ligne si la chaîne n'a pas de nouvelle ligne * /
    si (paquet-> données[i-1] ! = 10 && packet-> data[i-1] ! = 13)
        putchar (' n');

 
rc_packet * packet_build (int id, int cmd, char * s1)
/ * fonction hacky * /
    paquet statique de paquetage = 0, 0, 0, 0x00;
 
    / * taille + id + cmd + s1 + s2 terminaison NULL * /
    int s1_len = strlen (s1);
    if (s1_len> DATA_BUFFSIZE) 
        fprintf (stderr, "Avertissement: La chaîne de commande est trop longue (% d). Maximum autorisé:% d.  n", s1_len, DATA_BUFFSIZE);
        return NULL;
    
 
    packet.size = sizeof (int) * 2 + s1_len + 2;
    packet.id = id;
    packet.cmd = cmd;
    strncpy (packet.data, s1, DATA_BUFFSIZE);
 
    retour et paquet;

 
int rcon_auth (int rsock, char * passwd)

    int ret;
 
    rc_packet * packet = packet_build (RCON_PID, RCON_AUTHENTICATE, passwd);
    if (paquet == NULL) renvoie 0;
 
    ret = net_send_packet (rsock, packet);
    si (! ret) retourne 0; /* Echec de l'envoi */
 
    packet = net_recv_packet (rsock);
    if (paquet == NULL) renvoie 0;
 
    / * retourne 1 si authentification OK * /
    return packet-> id == -1? 0: 1;

 
int rcon_command (int rsock, char * commande)

    int ret;
 
    rc_packet * packet = packet_build (RCON_PID, RCON_EXEC_COMMAND, commande);
    si (paquet == NULL) 
        connexion_alive = 0;
        retourne 0;
    
 
    ret = net_send_packet (rsock, packet);
    si (! ret) retourne 0; /* Echec de l'envoi */
 
    packet = net_recv_packet (rsock);
    if (paquet == NULL) renvoie 0;
 
    if (packet-> id! = RCON_PID) renvoie 0; / * mauvais identifiant de paquet * /
 
    si (! silent_mode) 
        / *
        si (paquet-> taille == 10) 
            printf ("Commande inconnue "% s  ". Tapez " help  "ou "?  "pour obtenir de l'aide.  n", commande);
        
        autre
        * /
        si (paquet-> taille> 10)
            packet_print (packet);
    
 
    / * retourne 1 si le monde a été sauvé * /
    retourne 1;

 
int run_commands (int argc, char * argv[])

    int i, ok = 1, ret = 0;
 
    pour (i = optind; i < argc && ok; i++) 
        ok = rcon_command(rsock, argv[i]);
        ret += ok;
    
 
    return ret;

 
/* interactive terminal mode */
int run_terminal_mode(int rsock)

    int ret = 0;
    char command[DATA_BUFFSIZE] = 0x00;
 
    puts("Logged in. Type "Q" to quit!");
 
    while(connection_alive) 
 
        int len = get_line(command, DATA_BUFFSIZE);
        if(command[0] == 'Q' && command[1] == 0) break;
 
        if(len > 0 && connection_alive) ret + = rcon_command (rsock, commande);
 
        commander[0] = len = 0;
    
 
    retour ret;

 
/ * obtient une ligne de stdin et traite les déchets laissés dans le tampon d'entrée * /
int get_line (char * buffer, int bsize)

    int ch, len;
 
    fputs (">", stdout);
    fgets (buffer, bsize, stdin);
 
    si (tampon[0] == 0) connection_alive = 0;
 
    / * supprime les caractères indésirables de la mémoire tampon * /
    tampon[strcspn(buffer, "rn")] = ' 0';
 
    len = strlen (tampon);
 
    / * nettoie le tampon d'entrée si nécessaire * /
    if (len == bsize - 1)
        while ((ch = getchar ())! = ' n' && ch! = EOF);
 
    renvoyer len;