www.EspacioHacker.com

//////////////////////////////////////////////////////////////////////////////
//             SIMULACION DE CHAT A TRAVES DEL PUERTO SERIAL                //
//                             HECHO POR:                                   //
//                         WTC - [Dev/ Null]                                //
//                         WTC.LeGeND                                       //
//////////////////////////////////////////////////////////////////////////////

#include <dos.h>
#include <bios.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

//////////////////////////////////////////////////////////////////////////////
//        CONSTANTES PARA TRABAJAR CON LA CONFIGURACION DEL PUERTO          //
//////////////////////////////////////////////////////////////////////////////

#define COM1         0
#define COM_INIT     0
#define COM_SEND     1
#define COM_RECEIVE  2
#define COM_STATUS   3
#define COM_9600     0xE0
#define COM_CHR8     0x03
#define COM_STOP1    0x00
#define COM_NOPARITY 0x00
#define SETTINGS (COM_9600|COM_CHR8|COM_STOP1|COM_NOPARITY)
#define DATA_READY 0x100

//////////////////////////////////////////////////////////////////////////////
//                          OTRAS CONSTANTES                                //
//////////////////////////////////////////////////////////////////////////////

#define MAXU 10
#define MAXMSJ 41

//////////////////////////////////////////////////////////////////////////////
//                       FUNCIONES DE LA INTERFAZ                           //
//////////////////////////////////////////////////////////////////////////////

typedef struct{
int x1;
int y1;
int x2;
int y2;
}COORD;

// COORDENADAS DE ENTORNO
const COORD
BS={1,1,80,1},  //BARRA DE MENU SUPERIOR
BI={1,50,80,50},//BARRA INFERIOR
VS={2,3,59,39}, //VENTANA SUPERIOR
VI={2,42,59,48},//VENTANA INFERIOR
VU={62,3,79,48};//VENTANA DE USUARIOS

void initext(void){
textmode(C4350);
_setcursortype(_NOCURSOR);
textbackground(0);
textcolor(7);
clrscr();
}

void fondo(void){
textbackground(7);
textcolor(1);
clrscr();
gotoxy(1,2);
for(int i=0;i<3840;putch(176),i++);
textcolor(8);
gotoxy(62,50);
cprintf("Enviando Mensaje");
gotoxy(4,50);
cprintf("Recibiendo Mensaje");
}

void menu(char *cad){
window(BS.x1,BS.y1,BS.x2,BS.y2);
textbackground(7);
clrscr();
gotoxy(3,1);
textcolor(4);
for(;*cad;cad++){
  if(*cad==38){
   cad++;
   putch(32);
   textcolor(0);
  }//if
  if(*cad==32){
   putch(32);
   textcolor(4);
  }//if
  putch(*cad);
}//for
}

void marco(int x1,int y1,int x2,int y2,int ct){
int vx1=1,vy1=1,vx2=x2-x1+1,vy2=y2-y1+1;
textcolor(ct);
gotoxy(vx1,vy1+1); putch(201);
gotoxy(vx2,vy1+1); putch(187);
gotoxy(vx1,vy2); putch(200);
gotoxy(vx2,vy2); putch(188);
gotoxy(vx1,vy2-1); insline();
for(int i=vx1+1;i<vx2;i++){
  gotoxy(i,vy1); putch(205);
  gotoxy(i,vy2); putch(205);
}
for(i=vy1+1;i<vy2;i++){
  gotoxy(vx1,i); putch(186);
  gotoxy(vx2,i); putch(186);
}
gotoxy(3,1); putch(91);
textcolor(10); putch(254);
textcolor(ct); putch(93);
}

void ventana(int x1,int y1,int x2,int y2,int cf,int ct,char *cad){
window(x1,y1,x2,y2);
textbackground(cf);
textcolor(ct);
clrscr();
marco(x1,y1,x2,y2,ct);
gotoxy(((x2+x1)/2-strlen(cad)/2),1);
cprintf(" %s ",cad);
window(x1+1,y1+1,x2-1,y2-1);
}

void estado(int modo){
window(1,50,80,50);
textbackground(7);
textcolor(1+128);
switch(modo){
  case 1: gotoxy(62,1);
     cprintf("Enviando Mensaje");
     break;
  case 2: gotoxy(4,1);
     cprintf("Recibiendo Mensaje");
     break;
}//case
}


void efect(int modo){
static int i=0;
int x=0;
window(1,50,80,50);
textbackground(7);
textcolor(4);
switch(modo){
  case 1: x=78; break;
  case 2: x=2;  break;
}//case
gotoxy(x,1);
switch(i){
  case 0: cprintf(">");
     break;
  case 1: cprintf(">>");
     break;
  case 2: cprintf(" >");
     break;
}//case
switch(modo){
  case 1: delay(1); break;
  case 2: delay(2); break;
}//case
gotoxy(x,1);
textcolor(7);
cprintf(">>");
i++,i%=4;
}

void restarbi(void){
window(BI.x1,BI.y1,BI.x2,BI.y2);
textbackground(7);
textcolor(8);
clrscr();
gotoxy(4,1);
cprintf("Recibiendo Mensaje");
gotoxy(62,1);
cprintf("Enviando Mensaje");
}

void usuarios(int modo){
int x=2,y=2,i=1;
window(VU.x1,VU.y1,VU.x2,VU.y2);
textbackground(0);
switch(modo){
  case 1: for(;i<=MAXU;i++,y+=4){
      gotoxy(x,y);
      textcolor(4);
      cprintf("EMISOR   %d: ",i);
      gotoxy(x+2,y+1);
      textcolor(7);
      cprintf("Validos:");
      gotoxy(x+2,y+2);
      cprintf("No Validos:");
     }break;
  case 2: for(;i<=MAXU;i++,y+=4){
      gotoxy(x,y);
      textcolor(4);
      cprintf("RECEPTOR %d: ",i);
      gotoxy(x+2,y+1);
      textcolor(7);
      cprintf("Validos:");
      gotoxy(x+2,y+2);
      cprintf("No Validos:");
     }break;
  case 3: for(;i<=MAXU;i++,y+=4){
      gotoxy(x,y);
      textcolor(4);
      cprintf("USUARIO  %d: ",i);
      gotoxy(x+2,y+1);
      textcolor(7);
      cprintf("Entrada:");
      gotoxy(x+2,y+2);
      cprintf("Salida:");
     }break;
}//case
}

void actdes(int modo,int u,int ad){
window(VU.x1,VU.y1,VU.x2,VU.y2);
textbackground(0);
if(ad) textcolor(10);
else textcolor(4);
switch(u){
  case 0: gotoxy(2,2);  break;
  case 1: gotoxy(2,6);  break;
  case 2: gotoxy(2,10); break;
  case 3: gotoxy(2,14); break;
  case 4: gotoxy(2,18); break;
  case 5: gotoxy(2,22); break;
  case 6: gotoxy(2,26); break;
  case 7: gotoxy(2,30); break;
  case 8: gotoxy(2,34); break;
  case 9: gotoxy(2,38); break;
}//case
switch(modo){
  case 1: cprintf("EMISOR:   %d",u+1); break;
  case 2: cprintf("RECEPTOR: %d",u+1); break;
  case 3: cprintf("USUARIO:  %d",u+1); break;
}//case
}

void contmsj(int u,int c1,int c2){
window(VU.x1,VU.y1,VU.x2,VU.y2);
textbackground(0);
textcolor(12);
switch(u){
  case 0: gotoxy(16,3);
     cprintf("%d",c1);
     gotoxy(16,4);
     cprintf("%d",c2);
     break;
  case 1: gotoxy(16,7);
     cprintf("%d",c1);
     gotoxy(16,8);
     cprintf("%d",c2);
     break;
  case 2: gotoxy(16,11);
     cprintf("%d",c1);
     gotoxy(16,12);
     cprintf("%d",c2);
     break;
  case 3: gotoxy(16,15);
     cprintf("%d",c1);
     gotoxy(16,16);
     cprintf("%d",c2);
     break;
  case 4: gotoxy(16,19);
     cprintf("%d",c1);
     gotoxy(16,20);
     cprintf("%d",c2);
     break;
  case 5: gotoxy(16,23);
     cprintf("%d",c1);
     gotoxy(16,24);
     cprintf("%d",c2);
     break;
  case 6: gotoxy(16,27);
     cprintf("%d",c1);
     gotoxy(16,28);
     cprintf("%d",c2);
     break;
  case 7: gotoxy(16,31);
     cprintf("%d",c1);
     gotoxy(16,32);
     cprintf("%d",c2);
     break;
  case 8: gotoxy(16,35);
     cprintf("%d",c1);
     gotoxy(16,36);
     cprintf("%d",c2);
     break;
  case 9: gotoxy(16,39);
     cprintf("%d",c1);
     gotoxy(16,40);
     cprintf("%d",c2);
     break;
}//case
}

//////////////////////////////////////////////////////////////////////////////
//                         ESTRUCTURAS UTILIZADAS                           //
//////////////////////////////////////////////////////////////////////////////

typedef struct nodob{
int byte;
struct nodob *sig;
}NODOBYTE;

typedef struct{
NODOBYTE *frente;
NODOBYTE *final;
unsigned int cant;
}COLABYTE;

typedef struct{
int emisor;
int receptor;
char *cad;
int val;
}PAQUETE;

typedef struct nodop{
PAQUETE pack;
struct nodop *sig;
}NODOPACK;

typedef struct{
NODOPACK *frente;
NODOPACK *final;
unsigned int cant;
}COLAPACK;

typedef struct{
COLAPACK val;
COLAPACK noval;
unsigned int cant;
}MENSAJES;

typedef MENSAJES USUARIOS[MAXU];


//////////////////////////////////////////////////////////////////////////////
//             FUNCINES PARA TRABAJAR CON LAS COLAS DE BYTES                //
//////////////////////////////////////////////////////////////////////////////

void inicolabyte(COLABYTE *qb){
qb->frente=NULL;
qb->final=NULL;
qb->cant=0;
}

int colabytevacia(COLABYTE qb){
return((qb.frente)==NULL);
}

void encolarbyte(COLABYTE *qb,int byte){
NODOBYTE *aux=NULL;
aux=(NODOBYTE*)malloc(sizeof(NODOBYTE));
aux->byte=byte;
aux->sig=NULL;
qb->cant++;
if(qb->frente==NULL)
  qb->frente=aux;
else
  qb->final->sig=aux;
qb->final=aux;
}

int desencolarbyte(COLABYTE *qb,int *byte){
if(!colabytevacia(*qb)){
  NODOBYTE *aux=NULL;
  aux=qb->frente;
  *byte=qb->frente->byte;
  qb->frente=qb->frente->sig;
  qb->cant--;
  if(qb->frente==NULL){
   qb->final=NULL;
   qb->cant=0;
  }//if
  free(aux);
  return(1);
}//if
return(0);
}

int leerbytefrente(COLABYTE qb,int *byte){
if(!colabytevacia(qb)){
  *byte=qb.frente->byte;
  return(1);
}//if
return(0);
}

int leerbytefinal(COLABYTE qb,int *byte){
if(!colabytevacia(qb)){
  *byte=qb.final->byte;
  return(1);
}//if
return(0);
}

int borrarbytefrente(COLABYTE *qb){
if(!colabytevacia(*qb)){
  NODOBYTE *aux=qb->frente;
  qb->frente=qb->frente->sig;
  qb->cant--;
  if((qb->frente)==NULL){
   qb->final=NULL;
   qb->cant=0;
  }//if
  free(aux);
  return(1);
}//if
return(0);
}

void borrarcolabyte(COLABYTE *qb){
NODOBYTE *aux=NULL;
while(!colabytevacia(*qb)){
  aux=qb->frente;
  qb->frente=qb->frente->sig;
  free(aux);
}//while
qb->final=NULL;
qb->cant=0;
}

//////////////////////////////////////////////////////////////////////////////
//                 FUNCIONES PARA TRABAJAR CON PAQUETES                     //
//////////////////////////////////////////////////////////////////////////////

void inipack(PAQUETE *p){
p->emisor=0;
p->receptor=0;
p->cad=NULL;
p->val=0;
}

int packvacio(PAQUETE p){
if(p.cad==NULL)
  return(1);
return(0);
}

void borrarpack(PAQUETE *p){
p->emisor=0;
p->receptor=0;
if(p->cad)
  free(p->cad);
p->cad=NULL;
p->val=0;
}

//////////////////////////////////////////////////////////////////////////////
//           FUNCIONES PARA TRABAJAR CON LAS COLAS DE PAQUETES              //
//////////////////////////////////////////////////////////////////////////////

void inicolapack(COLAPACK *qp){
qp->frente=NULL;
qp->final=NULL;
qp->cant=0;
}

int colapackvacia(COLAPACK qp){
return((qp.frente)==NULL);
}

void encolarpack(COLAPACK *qp,PAQUETE p){
NODOPACK *aux=NULL;
aux=(NODOPACK*)malloc(sizeof(NODOPACK));
aux->pack.emisor=p.emisor;
aux->pack.receptor=p.receptor;
aux->pack.cad=(char*)malloc(strlen(p.cad)+1);
strcpy(aux->pack.cad,p.cad);
aux->pack.val=p.val;
aux->sig=NULL;
if(qp->frente==NULL)
  qp->frente=aux;
else
  qp->final->sig=aux;
qp->final=aux;
qp->cant++;
}

int desencolarpack(COLAPACK *qp,PAQUETE *p){
if(!colapackvacia(*qp)){
  NODOPACK *aux=NULL;
  aux=qp->frente;
  p->emisor=qp->frente->pack.emisor;
  p->receptor=qp->frente->pack.receptor;
  p->cad=qp->frente->pack.cad;
  p->val=qp->frente->pack.val;
  qp->frente=qp->frente->sig;
  qp->cant--;
  if(qp->frente==NULL){
   qp->final=NULL;
   qp->cant=0;
  }//if
  free(aux);
  return(1);
}//if
return(0);
}

int leerpackfrente(COLAPACK qp,PAQUETE *p){
if(!colapackvacia(qp)){
  *p=qp.frente->pack;
  return(1);
}//if
return(0);
}

int leerpackfinal(COLAPACK qp,PAQUETE *p){
if(!colapackvacia(qp)){
  *p=qp.final->pack;
  return(1);
}//if
return(0);
}

int borrarpackfrente(COLAPACK *qp){
if(!colapackvacia(*qp)){
  NODOPACK *aux=qp->frente;
  qp->frente=qp->frente->sig;
  qp->cant--;
  if((qp->frente)==NULL){
   qp->final=NULL;
   qp->cant=0;
  }//if
  borrarpack(&aux->pack);
  free(aux);
  return(1);
}//if
return(0);
}

void borrarcolapack(COLAPACK *qp){
NODOPACK *aux=NULL;
while(!colapackvacia(*qp)){
  aux=qp->frente;
  qp->frente=qp->frente->sig;
  borrarpack(&aux->pack);
  free(aux);
}//while
qp->final=NULL;
qp->cant=0;
}

//////////////////////////////////////////////////////////////////////////////
//       FUNCIONES PARA TRABAJAR CON EL VECTOR DE COLAS DE PAQUETES         //
//////////////////////////////////////////////////////////////////////////////
void inimensajes(MENSAJES *msjs){
inicolapack(&msjs->val);
inicolapack(&msjs->noval);
msjs->cant=0;
}

void iniusuarios(USUARIOS u){
for(int i=0;i<MAXU;i++)
  inimensajes(&u[i]);
}

void borrarmensajes(MENSAJES *msjs){
borrarcolapack(&msjs->val);
borrarcolapack(&msjs->noval);
msjs->cant=0;
}

void borrarusuarios(USUARIOS u){
for(int i=0;i<MAXU;i++)
  borrarmensajes(&u[i]);
}

int saveout(USUARIOS msjs,PAQUETE p){
if(p.val)
  encolarpack(&msjs[p.emisor-1].val,p);
else
  encolarpack(&msjs[p.emisor-1].noval,p);
msjs[p.emisor-1].cant=msjs[p.emisor-1].val.cant+msjs[p.emisor-1].noval.cant;
return(msjs[p.emisor-1].cant);
}

int savein(USUARIOS msjs,PAQUETE p){
if(p.val)
  encolarpack(&msjs[p.receptor-1].val,p);
else
  encolarpack(&msjs[p.receptor-1].noval,p);
msjs[p.receptor-1].cant=msjs[p.receptor-1].val.cant+msjs[p.receptor-1].noval.cant;
return(msjs[p.receptor-1].cant);
}

//////////////////////////////////////////////////////////////////////////////
//                   FUNCIONES PARA CREAR EL PAQUETE                        //
//////////////////////////////////////////////////////////////////////////////

int randomer(void){
return(random(10)+1);
}

int valout(void){
int por=random(100);
if((por>=0)&&(por<=70))
  return(1);
return(0);
}

char *mensaje(void){
FILE *in=fopen("a:\\mensajes.txt","rt");
if(in){
  char c=0,*cad=NULL,*aux=NULL;
  int i=0,ln=0,lr=random(MAXMSJ);
  while((c!=EOF)&&(ln!=lr)){
   c=(char)fgetc(in);
   if(c=='\n') ln++;
  }//while
  if(ln==lr){
   c=0;
   while((c!='\n')&&(c!=EOF)){
    c=(char)fgetc(in);
    i++;
   }//while
  }//if
  rewind(in);
  c=0,ln=0;
  while((c!=EOF)&&(ln!=lr)){
   c=(char)fgetc(in);
   if(c=='\n') ln++;
  }//while
  aux=(char*)malloc(i);
  cad=aux;
  if(ln==lr){
   *aux=(char)fgetc(in);
   while(*aux!='\n'){
    aux++;
    *aux=(char)fgetc(in);
   }//while
   *aux='\x0';
  }//if
  fclose(in);
  return(cad);
}//if
return(NULL);
}

void crearpack(PAQUETE *p){
if(!packvacio(*p))
  borrarpack(p);
p->emisor=randomer();
p->receptor=randomer();
p->cad=mensaje();
p->val=valout();
}

int numtec(char car){
switch(car){
  case '0': return(1);
  case '1': return(2);
  case '2': return(3);
  case '3': return(4);
  case '4': return(5);
  case '5': return(6);
  case '6': return(7);
  case '7': return(8);
  case '8': return(9);
  case '9': return(10);
}//case
return(0);
}

char *msjtec(void){
char buffer[83]="",*ap=NULL,*aux=NULL;
buffer[0]=81;
ap=cgets(buffer);
aux=(char*)malloc(strlen(ap)+1);
strcpy(aux,ap);
return(aux);
}

void tecpack(PAQUETE *p){
window(VI.x1,VI.y1,VI.x2,VI.y2);
textbackground(3);
textcolor(1);
_setcursortype(_NORMALCURSOR);
clrscr();
char car=0;
int x=0,y=0;
if(!packvacio(*p))
  borrarpack(p);
cprintf("0..9 Emisor: ");
x=wherex(),y=wherey();
while(car<'0'||car>'9'){
  gotoxy(x,y);
  car=getche();
}//while
cprintf("\n\r");
p->emisor=numtec(car); car=0;
cprintf("0..9 Receptor: ");
x=wherex(),y=wherey();
while(car<'0'||car>'9'){
  gotoxy(x,y);
  car=getche();
}//while
cprintf("\n\r");
p->receptor=numtec(car);
cprintf("Mensaje: ");
p->cad=msjtec();
p->val=1;
_setcursortype(_NOCURSOR);
}

//////////////////////////////////////////////////////////////////////////////
//         FUNCION QUE CONVIERTE UNA COLA DE BYTES EN UN PAQUETE            //
//////////////////////////////////////////////////////////////////////////////

void decodificar(COLABYTE *qb,PAQUETE *p){
int byte=0,er[2]={0,0},i=0,tamcad=0;
char *cad=NULL,*caux=NULL;
borrarpack(p);
desencolarbyte(qb,&byte);
while(((char)byte!='@')&&(!colabytevacia(*qb))){
  if((byte>=1)&&(byte<=10)){
   er[i]=byte;
   i++;
   i%=2;
  }//if
  desencolarbyte(qb,&byte);
}//while
if((char)qb->final->byte=='$'){
  qb->final->byte=(int)'\x0';
  p->val=1;
  tamcad=qb->cant;
}else tamcad=qb->cant+1;
caux=(char*)malloc(tamcad);
cad=caux;
desencolarbyte(qb,&byte);
while(!colabytevacia(*qb)){
  *caux=(char)byte;
  caux++;
  desencolarbyte(qb,&byte);
}//while
*caux=(char)byte;
if(!p->val){
  caux++;
  *caux='\x0';
}//if
p->emisor=er[0];
p->receptor=er[1];
p->cad=cad;
}

//////////////////////////////////////////////////////////////////////////////
//         FUNCION QUE CONVIERTE UN PAQUETE EN UNA COLA DE BYTES            //
//////////////////////////////////////////////////////////////////////////////

void codificar(COLABYTE *qb,PAQUETE p){
char *cad=NULL;
if(!colabytevacia(*qb))
  borrarcolabyte(qb);
encolarbyte(qb,p.emisor);
encolarbyte(qb,p.receptor);
encolarbyte(qb,(int)'@');
cad=p.cad;
while(*cad){
  encolarbyte(qb,(int)*cad);
  cad++;
}//while
if(p.val) encolarbyte(qb,(int)'$');

}

//////////////////////////////////////////////////////////////////////////////
//                 FUCION QUE CONTROLA LA BARA DE MENU                      //
//////////////////////////////////////////////////////////////////////////////

int funckey(void){
if(kbhit()){
  char key=getch();
  if(!key){
   key=getch();
   switch(key){
    case 59: return(1);
    case 60: return(2);
    case 61: return(3);
    case 62: return(4);
    case 63: return(5);
    case 64: return(6);
   }//case
  }//if
}//if
return(0);
}

//////////////////////////////////////////////////////////////////////////////
//                PROCEDIMIENTOS DE ESCRITURA EN PANTALLA                   //
//////////////////////////////////////////////////////////////////////////////

void printpackvs(PAQUETE p,int modo){
static int x=1,y=1;
window(VS.x1,VS.y1,VS.x2,VS.y2);
textbackground(1);
textcolor(3);
_setcursortype(_NOCURSOR);
gotoxy(x,y);
switch(modo){
  case 1: cprintf("Usuario %d Envia>> ",p.emisor);
     cprintf("%s\n\r",p.cad);
     cprintf(">>Para: Usuario %d\n\n\r",p.receptor);
     break;
  case 2: cprintf("Usuario %d Recive<< ",p.receptor);
     cprintf("%s\n\r",p.cad);
     cprintf(">>De Usuario %d",p.emisor);
     break;
}//case
delay(1000);
x=wherex();
y=wherey();
}

void printpackvi(PAQUETE p){
window(VI.x1,VI.y1,VI.x2,VI.y2);
textbackground(3);
textcolor(1);
_setcursortype(_NORMALCURSOR);
clrscr();
cprintf("Usuario %d Envia>> ",p.emisor);
cprintf("%s\n\r",p.cad);
cprintf(">>Para: Usuario %d\n\n\r",p.receptor);
_setcursortype(_NOCURSOR);
delay(1000);
}

void printbuzoner(USUARIOS v,int modo){
PAQUETE p;
inipack(&p);
if(modo==1)
  ventana(1,2,80,49,1,3,"Buzon de Salida");
else
  if(modo==2)
   ventana(1,2,80,49,1,3,"Buzon de Entrada");
for(int i=0;i<MAXU;i++){
  while(!colapackvacia(v[i].val)){
   desencolarpack(&v[i].val,&p);
   cprintf("Paquete Valido\n\r");
   cprintf("Emisor: %d\n\r",p.emisor);
   cprintf("Receptor: %d\n\r",p.receptor);
   cprintf("Mensaje: %s\n\r",p.cad);
   cprintf("Presione una Tecla Para Continuar...");
   cprintf("\n\n\r");
   borrarpack(&p);
   getch();
  }//while
  while(!colapackvacia(v[i].noval)){
   desencolarpack(&v[i].noval,&p);
   cprintf("Paquete No Valido\n\r");
   cprintf("Emisor: %d\n\r",p.emisor);
   cprintf("Receptor: %d\n\r",p.receptor);
   cprintf("Mensaje: %s\n\r",p.cad);
   cprintf("Presione una Tecla Para Continuar...");
   cprintf("\n\n\r");
   borrarpack(&p);
   getch();
  }//while
}//for
window(1,1,80,50);
fondo();
menu("F1&Emisor F2&Receptor F3&bidireccional F4&Buzon F5&Teclado F6&Salir");
}

void printbuzonb(USUARIOS vi,USUARIOS vs){
PAQUETE p;
inipack(&p);
ventana(1,2,80,49,1,3,"Buzon de Entrada");
for(int i=0;i<MAXU;i++){
  while(!colapackvacia(vi[i].val)){
   desencolarpack(&vi[i].val,&p);
   cprintf("Paquete Valido\n\r");
   cprintf("Emisor: %d\n\r",p.emisor);
   cprintf("Receptor: %d\n\r",p.receptor);
   cprintf("Mensaje: %s\n\r",p.cad);
   cprintf("Presione una Tecla Para Continuar...");
   cprintf("\n\n\r");
   borrarpack(&p);
   getch();
  }//while
  while(!colapackvacia(vi[i].noval)){
   desencolarpack(&vi[i].noval,&p);
   cprintf("Paquete No Valido\n\r");
   cprintf("Emisor: %d\n\r",p.emisor);
   cprintf("Receptor: %d\n\r",p.receptor);
   cprintf("Mensaje: %s\n\r",p.cad);
   cprintf("Presione una Tecla Para Continuar...");
   cprintf("\n\n\r");
   borrarpack(&p);
   getch();
  }//while
}//for
ventana(1,2,80,49,1,3,"Buzon de Salida");
for(i=0;i<MAXU;i++){
  while(!colapackvacia(vs[i].val)){
   desencolarpack(&vs[i].val,&p);
   cprintf("Paquete Valido\n\r");
   cprintf("Emisor: %d\n\r",p.emisor);
   cprintf("Receptor: %d\n\r",p.receptor);
   cprintf("Mensaje: %s\n\r",p.cad);
   cprintf("Presione una Tecla Para Continuar...");
   cprintf("\n\n\r");
   borrarpack(&p);
   getch();
  }//while
  while(!colapackvacia(vs[i].noval)){
   desencolarpack(&vs[i].noval,&p);
   cprintf("Paquete No Valido\n\r");
   cprintf("Emisor: %d\n\r",p.emisor);
   cprintf("Receptor: %d\n\r",p.receptor);
   cprintf("Mensaje: %s\n\r",p.cad);
   cprintf("Presione una Tecla Para Continuar...");
   cprintf("\n\n\r");
   borrarpack(&p);
   getch();
  }//while
}//for
window(1,1,80,50);
fondo();
menu("F1&Emisor F2&Receptor F3&bidireccional F4&Buzon F5&Teclado F6&Salir");
}

//////////////////////////////////////////////////////////////////////////////
//               FUNCION QUE ACTIVA Y DESACTIVA USUARIOS                    //
//////////////////////////////////////////////////////////////////////////////

void inivec(int v[MAXU]){
for(int i=0;i<MAXU;v[i]=0,i++);
}

void inier(int v[MAXU]){
for(int i=0;i<MAXU;v[i]=random(2),i++);
}

int adurandom(int v[MAXU]){
int u=random(10),
p=random(100);
if(p>=0&&p<=70)
  v[u]=1;
else
  v[u]=0;
return(u);
}


//////////////////////////////////////////////////////////////////////////////
//           FUNCIONES PARA TRANSMITIR Y RECIVIR POR EL PUERTO              //
//////////////////////////////////////////////////////////////////////////////

void inipuerto(void){
bioscom(COM_INIT,SETTINGS,COM1);
}

int bandera(void){
if(bioscom(COM_STATUS,0,COM1)&DATA_READY)
  return(1);
return(0);
}

void modoe(COLABYTE *qb){
int sale=0;
if(!colabytevacia(*qb)){
  estado(1);
  while(!colabytevacia(*qb)){
   desencolarbyte(qb,&sale);
   bioscom(COM_SEND,sale,COM1);
   efect(1);
  }//while
  restarbi();
}//if
}

void modor(COLABYTE *qb){
int entra=0;
if(!colabytevacia(*qb))
  borrarcolabyte(qb);
if(bandera()){
  estado(2);
  while(bioscom(COM_STATUS,0,COM1)&DATA_READY){
   if((entra=bioscom(COM_RECEIVE,0,COM1)&0x7F)!=0)
    encolarbyte(qb,entra);
   bioscom(COM_SEND,0,COM1);
   efect(2);
  }//while
  restarbi();
}//if
}

void modob(COLABYTE *qo,COLABYTE *qi){
int entra=0,sale=0;
while((bandera())||(!colabytevacia(*qo))){
  if(bandera()){
   estado(2);
   if((entra=bioscom(COM_RECEIVE,0,COM1)&0x7F)!=0)
    encolarbyte(qi,entra);
    bioscom(COM_SEND,0,COM1);
    efect(2);
  }//if
  if(!colabytevacia(*qo)){
   estado(1);
   desencolarbyte(qo,&sale);
   bioscom(COM_SEND,sale,COM1);
   efect(1);
  }//if
}//while
restarbi();
}

//////////////////////////////////////////////////////////////////////////////
//                         MODOS DE TRANSMISION                             //
//////////////////////////////////////////////////////////////////////////////

int emisor(void){
char c=0;
int u=0,v[MAXU],teclado=0;
inivec(v);
inier(v);
PAQUETE po;
COLABYTE qbo;
USUARIOS out;
inipuerto();
inipack(&po);
inicolabyte(&qbo);
iniusuarios(out);
for(int i=0;i<MAXU;actdes(2,i,v[i]),i++);
while(1){
  u=adurandom(v);
  actdes(1,u,v[u]);
  if(!teclado)
   crearpack(&po);
  else
   tecpack(&po);
  if(v[po.emisor-1]||teclado){
   saveout(out,po);
   codificar(&qbo,po);
   printpackvi(po);
   modoe(&qbo);
   printpackvs(po,1);
   contmsj(po.emisor-1,out[po.emisor-1].val.cant,out[po.emisor-1].noval.cant);
   teclado=0;
  }//if
  c=funckey();
  if(c){
   if(c>=1&&c<=3||c==6)
    goto salir;
   if(c==4)
    goto buzon;
   if(c==5)
    teclado=1;
  }//if
}//while
buzon:
printbuzoner(out,1);
salir:
borrarpack(&po);
borrarcolabyte(&qbo);
borrarusuarios(out);
return(c);
}

int receptor(void){
char c=0;
int u=0,v[MAXU];
inivec(v);
inier(v);
PAQUETE pi;
COLABYTE qbi;
USUARIOS in;
inipuerto();
inipack(&pi);
inicolabyte(&qbi);
iniusuarios(in);
for(int i=0;i<MAXU;actdes(2,i,v[i]),i++);
while(1){
  modor(&qbi);
  if(!colabytevacia(qbi)){
   decodificar(&qbi,&pi);
   savein(in,pi);
   if(v[pi.receptor-1])
    printpackvs(pi,2);
   contmsj(pi.receptor-1,in[pi.receptor-1].val.cant,in[pi.receptor-1].noval.cant);
   u=adurandom(v);
   actdes(2,u,v[u]);
  }//if
  c=funckey();
  if(c){
   if(c>=1&&c<=3||c==6)
    goto salir;
   if(c==4)
    goto buzon;
  }//if
}//while
buzon:
printbuzoner(in,2);
salir:
borrarpack(&pi);
borrarcolabyte(&qbi);
borrarusuarios(in);
return(c);
}

int bidireccional(void){
char c=0;
int u=0,v[MAXU],teclado=0;
inivec(v);
inier(v);
PAQUETE pi,po;
COLABYTE qbi,qbo;
USUARIOS in,out;
inipuerto();
inipack(&pi);
inipack(&po);
inicolabyte(&qbi);
inicolabyte(&qbo);
iniusuarios(in);
iniusuarios(out);
while(1){
  u=adurandom(v);
  actdes(3,u,v[u]);
  if(!teclado)
   crearpack(&po);
  else
   tecpack(&po);
  if(v[po.emisor-1]||teclado){
   saveout(out,po);
   codificar(&qbo,po);
   printpackvi(po);
   contmsj(po.emisor-1,in[po.emisor-1].cant,out[po.emisor-1].cant);
   teclado=0;
  }//if
  modob(&qbo,&qbi);
  if(v[po.emisor-1])
   printpackvs(po,1);
  if(!colabytevacia(qbi)){
   decodificar(&qbi,&pi);
   savein(in,pi);
   contmsj(pi.receptor-1,in[pi.receptor-1].cant,out[pi.receptor-1].cant);
   if(v[pi.receptor-1])
    printpackvs(pi,2);
  }//if
  c=funckey();
  if(c){
   if(c>=1&&c<=3||c==6)
    goto salir;
   if(c==4)
    goto buzon;
   if(c==5)
    teclado=1;
  }//if
}//while
buzon:
printbuzonb(in,out);
salir:
borrarpack(&po);
borrarpack(&pi);
borrarcolabyte(&qbo);
borrarcolabyte(&qbi);
borrarusuarios(out);
borrarusuarios(in);
return(c);
}

//////////////////////////////////////////////////////////////////////////////
//                        PROGRAMA PRINCIPAL                                //
//////////////////////////////////////////////////////////////////////////////

void programa(void){
randomize();
initext();
fondo();
menu("F1&Emisor F2&Receptor F3&bidireccional F4&Buzon F5&Teclado F6&Salir");
int func=0;
for(int i=0,v[MAXU];i<MAXU;v[i]=0,i++);i=0;
while(1){
  func=funckey();
  if(func){
   if(func>=1&&func<=3){
    ventana(61,2,80,49,0,7,"Usuarios");
    ventana(1,41,60,49,3,1,"Mensajes");
   }//if
   if(func==1){
    ventana(1,2,60,40,1,7,"Modo Emisor");
    usuarios(1);
    func=emisor();
   }//if
   if(func==2){
    ventana(1,2,60,40,1,7,"Modo Receptor");
    usuarios(2);
    func=receptor();
   }//if
   if(func==3){
    ventana(1,2,60,40,1,7,"Bidireccional");
    usuarios(3);
    func=bidireccional();
   }//if
   if(func==6) goto salir;
  }//if
}//while
salir:
}

//////////////////////////////////////////////////////////////////////////////
//                     LLAMADA AL PROGRAMA PRINCIPAL                        //
//////////////////////////////////////////////////////////////////////////////

void main(){
programa();
}