dslinux/user/bitchx/dll/nap/dragonap/napi Makefile commands.h main main.c napi.c napi.h

stsp stsp at user.in-berlin.de
Sun Jul 2 15:18:36 CEST 2006


Update of /cvsroot/dslinux/dslinux/user/bitchx/dll/nap/dragonap/napi
In directory antilope:/tmp/cvs-serv9280/dll/nap/dragonap/napi

Added Files:
	Makefile commands.h main main.c napi.c napi.h 
Log Message:
Adding pristine copy of BitchX so I can branch from it.


--- NEW FILE: commands.h ---
/*
napster code base by Drago (drago at 0x00.org)
released: 11-30-99
*/

#ifndef COMMANDS_H
#define COMMANDS_H
enum recv_Commands {
	CMDR_STATS=214,
	CMDR_EMAILADDR=3,
	CMDR_MOTD=109,
	CMDR_SEARCHRESULTS=201,
	CMDR_SEARCHRESULTSEND=202,
	CMDR_ERROR=0,
	CMDR_ANOTHERUSER=148,
	CMDR_SENDFILE=95,
	CMDR_USERSPEED=209,
	CMDR_REQUESTUSERSPEED=89,
	CMDR_FILEREADY=204,
	CMDR_GETERROR=206,
	CMDR_GETQUEUE=108
};


enum send_Commands {
	CMDS_LOGIN=2,
	CMDS_SEARCH=200,
	CMDS_REQUESTFILE=203,
	CMDS_ADDFILE=100,
	CMDS_ADDHOTLIST=208
};
#endif

--- NEW FILE: napi.c ---
/*
napster code base by Drago (drago at 0x00.org)
released: 11-30-99
*/

#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdarg.h>
#include <time.h>
#include <sys/time.h>
#include <assert.h>

#include "napi.h"


_N_SERVER *n_GetServer(void) {
	char serverline[1024], *server;
	int fd, r, port;
	struct sockaddr_in socka;
	static _N_SERVER theserver;

	fd=socket(AF_INET, SOCK_STREAM, 0);
	socka.sin_addr.s_addr=inet_addr(n_nslookup(N_DISTRO_SERVER));
	socka.sin_family=AF_INET;
	socka.sin_port=htons(N_DISTRO_SERVER_PORT);

	if (connect(fd, (struct sockaddr *)&socka, sizeof(struct sockaddr))!=0) {
		n_Error("connect()");
		close(fd);
		return NULL;
	}

	r=read(fd, serverline, sizeof(serverline));
	if (r==-1) {
		n_Error("read()");
		close(fd);
		return NULL;
	}
	server=strstr(serverline, ":");
	if (!server) {
		n_Error("No port token?");
		close(fd);
		return NULL;
	}

	*server='\0';
	server++;
	port=atoi(server);
	server=serverline;

	strncpy(theserver.address, server, sizeof(theserver.address));
	theserver.port=port;

	n_Debug("Server: %s Port: %d", theserver.address, theserver.port);
	close(fd);
	return &theserver;
}

char *n_nslookup(char *addr) {
	struct hostent *h;
	if ((h=gethostbyname(addr)) == NULL) {
		return addr;
	}
	return (char *)inet_ntoa(*((struct in_addr *)h->h_addr));
}

int n_Connect(_N_SERVER *s, _N_AUTH *a) {
	int r, port;
	struct sockaddr_in socka;

	n_serverfd=socket(AF_INET, SOCK_STREAM, 0);
	socka.sin_addr.s_addr=inet_addr(n_nslookup(s->address));
	socka.sin_family=AF_INET;
	socka.sin_port=htons(s->port);

	if (connect(n_serverfd, (struct sockaddr *)&socka, sizeof(struct sockaddr))!=0) {
		n_Error("connect()");
		close(n_serverfd);
		return 0;
	}

	n_Debug("Connected");

	n_SendCommand(CMDS_LOGIN, "%s %s %d \"v2.0 BETA 3\" %d", a->username, a->password, n_dataport, n_connectionspeed);
	{
		_N_COMMAND *cmd;
		cmd=n_GetCommand();
		if (cmd->cmd[2]==CMDR_ERROR) {
			n_Error("%s", cmd->data);
			return 0;
		} else {
			n_HandleCommand(cmd);
		}
	}
	return 1;
}

void n_HandleCommand(_N_COMMAND *cmd) {
	switch (cmd->cmd[2]) {
		case CMDR_MOTD:
			if (n_HookMotd) {
				n_HookMotd(cmd->data);
			} else {
				n_Debug("No motd hook installed");
			}
		break;
		case CMDR_STATS:
/*
			D:napi.c:n_GetCommand():171:Data: 2104 197246 798
			2104==Libraries
			197246==songs
			798==gigs
*/
			if (n_HookStats) {
				_N_STATS s;
				if (sscanf(cmd->data, "%d %d %d",
					&s.libraries, &s.songs, &s.gigs)!=3) {
					n_Error("Too few args");
				}
				else n_HookStats(&s);
			} else {
				n_Debug("No stats hook installed");
			}
		break;
	}
}

void n_SendCommand(_N_CMD ncmd, char *fmt, ...) {
	char buff[2048];
	_N_COMMAND command;
	va_list ap;

	va_start(ap, fmt);

	command.cmd[0]=vsnprintf(buff, sizeof(buff), fmt, ap);
	va_end(ap);

	command.cmd[1]='\0';
	command.cmd[2]=ncmd;
	command.cmd[3]='\0';

	n_Debug("Flags: %d %d %d %d", command.cmd[0], command.cmd[1], command.cmd[2], command.cmd[3]);
	n_Debug("Data: %s", buff);

	n_Send(command.cmd, sizeof(command.cmd));
	n_Send(buff, command.cmd[0]);
}

int n_Send(char *data, int s) {
	return write(n_serverfd, data, s);
}

int n_Loop(void) {
	int sret;
	struct timeval tv;
	fd_set rfd;
	FD_ZERO(&rfd);
	FD_SET(n_serverfd, &rfd);
	tv.tv_sec=0;
	tv.tv_usec=0;

	sret = select(n_serverfd+1, &rfd, NULL, NULL, &tv);
	if (sret>0) {
		if (FD_ISSET(n_serverfd, &rfd)) {
			n_DoCommand();
			return 1;
		}
	}
}

_N_COMMAND *n_GetCommand(void) {
	static char rbuff[1024];
	static _N_COMMAND command;
	read(n_serverfd, command.cmd, sizeof(command.cmd));
	if (command.cmd[1]==0) {
		int r;
		assert(sizeof(rbuff) > command.cmd[0]);
		r=n_ReadCount(rbuff, command.cmd[0]);
	} else {
		int r=0;
		int cc=command.cmd[3]+1;
		while(cc>0) {
			assert(sizeof(rbuff) > r);
			if (read(n_serverfd, &rbuff[r], sizeof(char))==1) r++;
			if (rbuff[r-1]=='.') cc--;
		}
		rbuff[r]=0;
	}
	command.data=rbuff;
        n_Debug("Flags: %d %d %d %d", command.cmd[0], command.cmd[1], command.cmd[2], command.cmd[3]);
        n_Debug("Data: %s", command.data);
	return &command;
}

void n_DoCommand(void) {
	_N_COMMAND *cmd;
	cmd=n_GetCommand();
	n_HandleCommand(cmd);
}

int n_ReadCount(char *buff, int c) {
	int rc=0;
	while (c>rc) {
		if (read(n_serverfd, &buff[rc], sizeof(char))==1) rc++;
	}
	buff[rc]=0;
}

void n_SetMotdHook(void (*f)(char *)) {
	n_HookMotd=f;
	n_Debug("Installed motd hook");
}

void n_SetStatsHook(void (*f)(_N_STATS *)) {
	n_HookStats=f;
	n_Debug("Installed stats hook");
}


--- NEW FILE: main.c ---
/*
napster code base by Drago (drago at 0x00.org)
released: 11-30-99
*/

#include "napi.h"

void motdhook(char *s) {
	printf("MOTD: %s\n", s);
}

void statshook(_N_STATS *s) {
	printf("Stats: Libraries==%d Songs==%d Gigs==%d\n", s->libraries, s->songs, s->gigs);
}

int main(void) {
	_N_SERVER *s;
	_N_AUTH a={"dragotest", "nap"};
	n_SetMotdHook(motdhook);
	n_SetStatsHook(statshook);
	s=n_GetServer();
	if (!n_Connect(s, &a)) {
		printf("Error connecting\n");	
		return 1;
	}
	while(1) n_Loop();
}

--- NEW FILE: main ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: Makefile ---
all:
	gcc -o main main.c napi.c

--- NEW FILE: napi.h ---
/*
napster code base by Drago (drago at 0x00.org)
released: 11-30-99
*/

#include <stdio.h>
#include <errno.h>
#include "commands.h"

#ifndef NAPI_H
#define NAPI_H

int n_serverfd;
int n_connectionspeed;
int n_dataport;

#define N_DEBUG
#define N_DISTRO_SERVER "server.napster.com"
#define N_DISTRO_SERVER_PORT 8875

/* Error faculty */
#define n_Error(fmt, args...) \
	do { \
		fprintf(stderr, "E:%s:%s():%d:%s:", __FILE__, __FUNCTION__, __LINE__, strerror(errno)); \
		fprintf(stderr, fmt, ## args); \
		fprintf(stderr, "\n"); \
	} while (0)

/* Debug faculty.....duh? */
#ifdef N_DEBUG
# define n_Debug(fmt, args...) \
	do { \
		fprintf(stderr, "D:%s:%s():%d:", __FILE__, __FUNCTION__, __LINE__); \
		fprintf(stderr, fmt, ## args); \
		fprintf(stderr, "\n"); \
	} while (0)
#else
# define n_Debug(fmt, args...) (void)0
#endif

typedef struct {
	char address[100];
	int port;
} _N_SERVER;

typedef struct {
	char username[100];
	char password[100];
} _N_AUTH;

typedef unsigned char _N_CMD;

typedef struct {
	_N_CMD cmd[4];
	char *data;
} _N_COMMAND;

typedef struct {
	int libraries;
	int gigs;
	int songs;
} _N_STATS;

/* Get a napster server */
_N_SERVER *n_GetServer(void);

/* Connect to a napster server */
int n_Connect(_N_SERVER *, _N_AUTH *);

/* nslookup helper function */
char *n_nslookup(char *addr);

/* Send a napster command */
void n_SendCommand(_N_CMD, char *, ...);

/* Send raw napster data */
int n_Send(char *, int);

/* This is the main napster loop */
int n_Loop(void);

/* Command handler */
_N_COMMAND *n_GetCommand(void);

/* Force a read of X bytes */
int n_ReadCount(char *, int);

/* MOTD hook handling */
void (*n_HookMotd)(char *);
void n_SetMotdHook(void (*)(char *));

/* Stats hook handling */
void (*n_HookStats)(_N_STATS *);
void n_SetStatsHook(void (*)(_N_STATS *));

void n_DoCommand(void);
void n_HandleCommand(_N_COMMAND *);

#endif




More information about the dslinux-commit mailing list