Procesos. Aspectos básicos
|
|
- Pascual Naranjo Belmonte
- hace 6 años
- Vistas:
Transcripción
1
2 Procesos Aspectos básicos 1. Atributos de un proceso 2. Tabla de procesos y área de usuario 3. Planificadores 4. Comandos a. ipcs b. ipcrm 5. Creación procesos 6. Llamadas al sistema. 7. Como manipular proceso a. Comunicación usando archivos b. Pipe c. Memoria compartida d. FIFO e. Socket 8. Procesos y señales.(tinaco y temporizador) Sincronización entre procesos 1. Semáforos(volumen) Ejemplo procesos 1. FIFO (lotería) 2. Memoria compartida(mínimos) 3. Colas de mensajes(simulación cajas) 4. Socket(cajeros)
3 Procesos Atributos de proceso Qué es exactamente un proceso? Un proceso es una instancia de un programa en ejecución y también la unidad básica de planificación de Linux. Básicamente tres son los estados de un proceso Estados 1. En ejecución Utiliza la CPU en el instante dado 2. Listo Ejecutable, se detiene en forma temporal para que se ejecute otro proceso 3. Bloqueado No se puede ejecutar debido a la ocurrencia de algún evento externo La transición de los estados de un proceso se lleva de la siguiente manera: 1. El proceso se bloquea en espera de datos 2. El planificador elije otro proceso 3. El planificador elige este proceso 4. Los datos están disponibles
4 Planificadores
5 Comando ipcs Cuando se trabaja con procesos y los mecanismos de comunicación entre ellos son importantes y para verificar la correcta comunicación el comando ipcs es de gran ayuda, a través de este comando se puede verificar los semáforos, memoria compartida y cola de mensajes. Para verificar el comando y sus acciones tecleamos #ipcs -h Si solo se teclea solo ipcs proporciona estado de los segmentos de memoria compartida, semáforos y cola de mensajes.
6
7 Comando ipcrm Al trabajar con mecanismo de tipo FIFO es importante conocer el comando ipcrm que tiene como tareas borrar mensajes, semáforos o indicadores de memoria compartida Su sintaxis se es la siguiente: Donde: Opción Acción -m shmid Borra el segmento de memoria compartida con identificador shmid -q msgid Borra la cola de mensaje don identificador msgid -s semid Borra el semáforo con identificador semid -M shmkey Borra la memoria compartida, que tiene como llave shmkey -Q msqkey Borra la cola de mensaje, creada con la llave msqkey -S semkey Borra el semáforo, creado con la llave semkey Ejemplo: Para ejemplificar más crearemos dos colas de mensajes
8 Verificamos su creación Y a continuación las eliminaremos desde la terminal y verificamos el estado.
9 Creación de un proceso (fork) Para la creación de un nuevo proceso se utiliza una llamada al sistema fork, la cual crea un nuevo proceso. El nuevo proceso, o proceso hijo será una copia del proceso que llama, o proceso padre. Su sintaxis de fork es: \beginverbatim #include <unistd.h> pid_t fork( ); \endverbatim la forma de invocarla es pid=fork(). La llamada a fork hace que el proceso actual se duplique. A la ejecución de fork, los dos procesos tiene una copia idéntica del contexto del nivel de usuario en otras palabra se podría decir que todo lo que se encuentra antes de fork se hereda mas no implica que su variables sean compartidas entre procesos, cabe mencionar que para realizar esta tarea existes otro mecanismos de comunicación como por ejemplo memoria compartida, además sus identificadores de procesos(pid) son diferentes, el proceso padre toma el valor del PID del proceso hijo y para el proceso hijo toma el valor 0, El proceso 0, creado por el núcleo cuando arranca el sistema, es el único que no se crea con una llamada a fork. Figura1
10 Si la llamada a fork falla, devolverá el valor -1, (ver figura 1) Cuando llamamos a fork, el núcleo realiza las siguientes operaciones: Busca una entrada libre en la tabla de procesos y la reserva para el proceso hijo. Asigna un identificador de proceso PID para el proceso hijo. Este número es único e invariable durante toda la vida del proceso y es la clave para poder controlar desde otro proceso. Realiza una copia del contexto del nivel de usuario del proceso padre para el proceso hijo. Las secciones que deben ser compartidas, como el código o las zonas de memoria compartida, no se copia, sino que se incrementan los contadores que indican cuántos procesos comparten esa zonas. Las tablas de control de fichero locales al proceso -como pueden ser la tabla de descriptores de archivos- también se copian del proceso padre al proceso hijo, ya que forman parte del contexto del nivel usuario. En las tablas globales del núcleo - tabla de ficheros y tabla de inodes- se incrementan los contadores que indican cuántos procesos tienen abiertos esos ficheros. Rertorna el proceso padre el PID del proceso hijo, y al proceso hijo le devuelve el valor 0. Cuando se hace programación concurrente con procesos o hilos dos aspectos son muy importantes para un correcto funcionamiento como son: sincronización y comunicación. Terminación de procesos (exit y wait) Existen múltiples mecanismo de sincronización de procesos como son: semáforos, monitores, variables de condición y mutex, ya que es uno de los problemas más difíciles cuando se hace programación concurrente, los más sencillos son usando la llamada al sistema sleep o exit y wait, no son los mecanismos más recomendados.
11 exit Una situación muy típica en programación concurrente es que el proceso padre espere a la terminación del proceso hijo antes de terminar su ejecución. Un ejemplo de esta situación es la forma de operar de los intérpretes de órdenes. Cuando escribimos una orden, el intérprete arranca un proceso para ejecutarla y no devuelve el control hasta que no se ha ejecutado completamente. Naturalmente, esto no se aplica cuando la orden se ejecuta en segundo plano. Para sincronizar los procesos padre e hijo se emplean las llamadas exit" y \verb"wait". La declaración de \verb"exit" es la siguiente: \beginverbatim #include <stdio.h> void exit(int status); \endverbatim Esta llamada termina la ejecución de un proceso y le devuelve el valor de \verb"status" al sistema.\\ La llamada exit tien además las siguientes consecuencias: \beginitemize \item Las funciones registradas por \verb"atexit" son invocadas en orden inverso a como fueron resgistradas. \verb"atexit" permite indicarle al sistemas las acciones que se deben ejecutar al producirse la terminación de un proceso. \item El contexto del proceso es descargado de memoria, lo que implica que la tabla de descriptores de fichero es cerrada y sus ficheros asociados cerrados, si no quedan más procesos que los que tengan abiertos. \item Si el proceso padre está ejecutando una llamada a \verb"wait", se le notifica la terminación de su proceso hijo y se le envia 8 bits menos significativos de status. Con esta información, el proceso padre puede saber en qué condiciones ha terminado el proceso hijo. \item Si el proceso padre no está ejecutando una llamada a \verb"wait", el proceso hijo se transforma en un proceso \textcolorrojozombi. Un proceso
12 Llamadas al sistema Suponiendo que existe una archivo llamado "suma" o en caso contrario se crear usando #vi suma o usando un editor grafico, y está organizado de la siguiente manera: //proceso5.c #include <stdio.h> #include <wait.h> #include <sys/types.h> #include <unistd.h> #include <errno.h> #include <stdlib.h> #define n 6 static char *cmd[]="who","ls","date","ps","uname"; int j,i,pid,status,proc; int buf; FILE *fp; int process_fork(int nproc) int i; for(i=1; i<=nproc-1;i++) if(fork()==0) return(i); return(0); main() j=rand()%5; /* utilizado por el proceso uno*/ pid=process_fork(n); switch(pid) case 0: printf("estoy en proceso"); for(i=1;i<=n;i++) wait(&i); fprintf(stdout,"\n\n padre con ID=%d \n\n",getpid()); exit(1); case 1: fprintf(stdout,"\n proceso 1 con ID=%d \n\n",getpid()); execlp(cmd[j],cmd[j],0); exit(0); case 2: fprintf(stdout,"\n proceso 2 con ID=%d \n\n",getpid());
13 system("sort -n suma"); exit(0); case 3: fprintf(stdout,"\n proceso 3 con ID=%d \n\n",getpid()); execlp("sort","sort","-n","suma",0); exit(0); case 4: fprintf(stdout,"\n proceso 4 con ID=%d \n\n",getpid()); if((fp=fopen("suma","r"))==null) printf("error al abri el archivo"); exit(0); else printf("buscando archivo \n"); while(!feof(fp)) fscanf(fp,"%d",&buf); printf("%d \n",buf); fclose(fp); exit(0); case 5: fprintf(stdout,"\n proceso 5 con ID=%d \n\n",getpid()); if((fp=fopen("suma","a"))==null) printf("error al abrir el archivo/escritura"); exit(0); else printf("escribiendo archivo \n"); fprintf(fp,"%d\n",2000); fclose(fp); exit(0); default: printf("no hay tal comando \n"); exit(0); wait(&status);
14
15
16 COMUNICACIÓN ENTRE PROCESOS En cuanto a la comunicación existen varios mecanismos de comunicación. A continuación se plantea una forma simple de comunicación, la cual consiste en utilizar un archivo para comunicar procesos Ejemplo: se tiene un conjunto de datos A=ai ai R 0 i 99, y se generan cuatro procesos(p1,p2,p3,p4) y el proceso padre(p0), cada hijo con una rebanada de 25 datos A1= ai 0 i 24 P1=min(A1) A2= ai 25 i 49 P2=min(A2) A3= ai 50 i 74 P3=min(A3) A4= ai 75 i 99 P4=min(A4) P0=min P1,P2, P3,P4 #include <stdio.h> #include <string.h> #include <wait.h> #include <sys/types.h> #include <unistd.h> #include <errno.h> #include <stdlib.h> int j,i,pid,status,proc,min=100,imin; int buf; FILE *fp; int cont=0,a[100]; char s2[20]; int process_fork(int nproc) int i; for(i=1;i<=nproc-1;i++) if(fork()==0) return(i); return(0); main() strcpy(s2,"minimo.txt");
17 fp= fopen (s2,"w+"); printf("valores del vector a[100]\n"); for(i=0;i<100;i++) a[i]=rand()%100; printf("%d ",a[i]); if(((cont+1)%25)==0)printf("\n"); cont++; printf("\n\n"); pid=process_fork(5); switch(pid) case 0: for(i=1;i<5;i++) wait(&i); printf("\n"); fp= fopen (s2,"r+"); while(!feof(fp)) fscanf(fp,"%d",&j); printf("** %d ** ",j); if(min>j) min=j; fclose(fp); printf("\n padre ID=%d valor minimo total %d\n",getpid(),min); remove(s2); exit(0); case 1: printf("\n"); min = a[0]; imin = 0; for (i=0; i<=24; i++) if (a[i]<min) min = a[i]; printf("%d ",a[i]); printf("\n minimo parcial %d proceso 1 ID %d \n", min,getpid()); fprintf(fp,"%d\n",min); fclose ( fp ); exit(0); case 2: printf("\n"); min = a[25]; imin = 0; for (i=25; i<=49; i++) if (a[i]<min) min = a[i]; printf("%d ",a[i]); printf("\nminimo parcial %d proceso 2 ID %d \n", min,getpid());
18 fprintf(fp, "%d\n",min); fclose ( fp ); exit(0); case 3: printf("\n"); min = a[50]; imin = 0; for (i=50; i<=74; i++) if (a[i]<min) min = a[i]; printf("%d ",a[i]); printf("\nminimo parcial %d proceso 3 ID %d \n", min,getpid()); fprintf(fp, "%d\n",min); fclose ( fp ); exit(0); case 4: printf("\n"); min = a[75]; imin = 0; for (i=75; i<=99; i++) if (a[i]<min) min = a[i]; printf("%d ",a[i]); printf("\nminimo parcial %d proceso 4 ID %d \n", min,getpid()); fprintf(fp, "%d\n",min); fclose ( fp ); exit(0); default: printf("no hay tal comando \n"); exit(0); exit(0);
19
20 Pipe En cuanto al mecanismo de comunicación de tuberías hablaremos poco ya que solo el sistema operativo lo utiliza para comunicación y que nos es más que la comunicación utilizando un archivo como se planteo en la sección anterior, y son pocos utilizados programadores, cabe comentar que a veces los comandos no se ejecutan en el orden en que se proporcionan. Ejemplo: Tenemos un archivo llamado pba.txt Y se le da al sistema operativo la orden siguiente #cat pba.txt sort n Conducto sin cat pba.txt sort -n nombre Proceso 1 Archivo temporal Proceso 2
21 El resultado es el siguiente: Existen dos tipo de tuberías una llamada tuberías sin nombres y una con nombre y pueden ser direccionales o bidireccionales
22 Memoria compartida La forma más rápida y una de las más usadas de comunicar dos procesos es hacer que compartan una zona de memoria. Para enviar datos de un proceso a otro, solo hay que escribir en memoria y automáticamente estos datos estarán disponibles para que los lea otro proceso.. M e m o r i a Var Llave acceso Apuntador Var Var Apuntador Proceso 1 Proceso 2 Recordemos que los procesos no comparten memoria, no basta con declarar la variable como global, si se quiere compartir memoria tiene que implementarse primero, además se tiene que usar semáforos como mecanismo de sincronización para proteger la sección critica.
23 Los paso son los siguiente Proceso Obtener un manejador A través de shmid= shmid(llave,sizeof(..), ); Anclar el segmento a una estructura definida dentro del proceso var=shmat(shmid,0,0); Leer /escribir var Quitar el ancla shmdt(var) Borrar segmento de memoria shmctl(shmid,ipc_rmid,0); Fin del Proceso Como ejemplo resolveremos el mismo problema visto al inicio de la comunicación entre procesos. #include <stdlib.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h> #include <sys/sem.h> #include <stdio.h>
24 #include <errno.h> void spin_lock_init(); //inicializa los semáforos void spin_lock(); //P void spin_unlock();//v key_t shm_key; int shmid, semid, pid; char *shm; int *A, *addr; int i,j=10, *vol,*vol2;; int minimos[5]; int j,i,pid,status,proc; int cont,min,imin, a[100]; int process_fork(int nproc) int i; for(i=1;i<=nproc-1;i++) if(fork()==0) return(i); return(0); main() spin_lock_init(&semid); shm_key=0x5675; //shmget devuelve devuelve un entero shmid=shmget(shm_key,sizeof(minimos),(ipc_creat 0600)); vol=shmat(shmid,0,0); //shmat devuelve un puntero char vol2=vol; printf("valores del vector a[100]\n"); for(i=0;i<100;i++) a[i]=rand()%100; printf("%d ",a[i]); if(((cont+1)%25)==0)printf("\n");
25 cont++; printf("\n\n"); pid=process_fork(5); switch(pid) case 0: for(i=1;i<5;i++) wait(&i); printf("\n"); min=vol[0]; for(i=1;i<4;i++) if(vol[i]<min)min=vol[i]; printf("\n padre ID=%d valor minimo total %d\n",getpid(),min); exit(0); case 1: printf("\n"); min = a[0]; imin = 0; for (i=0; i<=24; i++) if (a[i]<min) min = a[i]; printf("%d ",a[i]); printf("\n padre ID=%d valor minimo total %d\n",getpid(),min); spin_lock(&semid); vol[pid-1]=min; spin_unlock(&semid); exit(0); case 2: printf("\n"); min = a[25]; imin = 0; for (i=25; i<=49; i++) if (a[i]<min) min = a[i]; printf("%d ",a[i]); printf("\n padre ID=%d valor minimo total %d\n",getpid(),min); spin_lock(&semid); vol[pid-1]=min; spin_unlock(&semid); exit(0); case 3:
26 printf("\n"); min = a[50]; imin = 0; for (i=50; i<=74; i++) if (a[i]<min) min = a[i]; printf("%d ",a[i]); printf("\n padre ID=%d valor minimo total %d\n",getpid(),min); spin_lock(&semid); vol[pid-1]=min; spin_unlock(&semid); exit(0); case 4: printf("\n"); min = a[75]; imin = 0; for (i=75; i<=99; i++) if (a[i]<min) min = a[i]; printf("%d ",a[i]); printf("\n padre ID=%d valor minimo total %d\n",getpid(),min); spin_lock(&semid); vol[pid-1]=min;; spin_unlock(&semid); exit(0); default: printf("no hay tal comando \n"); exit(0); if(semctl(semid,0,ipc_rmid,1)==-1) perror("semctl"); exit(1); if(shmctl(shmid,ipc_rmid,0)==-1) perror("shmctl"); exit(1); exit(0);
27 //inicializa los semaforos void spin_lock_init(int *lok) int init_sem_value=1; *lok=semget(ipc_private,1,(0600 IPC_CREAT)); if(*lok==-1) perror("semget"); exit(1); if(semctl(*lok,0,setval,init_sem_value)<0) perror("semctl"); exit(1); /*end of spin_lock_init */ // Operación P void spin_lock(int *lok) struct sembuf sembuffer, *sops; sops=&sembuffer; sops->sem_num=0; sops->sem_op=-1; sops->sem_flg=0; if(semop(*lok,sops,1)<0) perror("semop"); exit(1); /*end of spin_lock */ //operación V void spin_unlock(int *lok) struct sembuf sembuffer, *sops; sops=&sembuffer; sops->sem_num=0; sops->sem_op=1; sops->sem_flg=0; if(semop(*lok,sops,1)<0) error("semop"); exit(1);
28 /*end of spin_unlock */
29 in out Colas de mensajes El mecanismo conocido como cola de mensajes es una lista enlazada y almacenada en el núcleo la cual tienen un id, este último es similar al de memoria compartida y semáforos. De forma básica diremos que los mensajes tienen una estructura de acuerdo a los datos a ser almacenados, y opera de la siguiente manera mensaje n Etiqueta n.. mensaje 3 Etiqueta 3 mensaje 2 Etiqueta 2 mensaje 1 Etiqueta 1 Como podemos observar opera como una estructura de datos conocida como cola, a excepción de que si conoce la etiqueta (número) puede sacar el mensaje correspondiente sin necesidad de sacar los mensajes anteriores a el, a través de la función msgrcv( ). Cada mensaje consiste en dos partes, las cuales están definidas en la estructura struct msgbuf, tal como aparece en sys/msg.h: Donde: struct msgbuf long mtype; char mtext[1]; mtype Es usado para recibir mensajes, y puede ser cualquier número positivo. mtext Es el dato que se añadirá a la cola, este campo puede variar según las necesidades del programador. Esta estructura es la más básica, pero puede ampliarse a mas campos de datos, el único campo que es necesario es long mtype,
30 Además type msgrcv( ) 0 Recibe el próximo mensaje de la cola (el de arriba). > Se devuelve el primer mensaje cuyo msg_type sea igual a type. < se devuelve el primer mensaje cuyo msg_type sea el menor valor o igual que el valor absoluto de type Previamente describimos comandos para trabajar y verificar el estado de los mecanismos de comunicación, en este apartado solo hablaremos específicamente sobre el uso para colas de mensajes. Si queremos ver la colas activa del núcleo y su estado, tecleamos el #ipcs q Para eliminar una cola desde la línea de comandos tecleamos #ipcrm q id_cola
31 El siguiente ejemplo genera una colas de mensaje, envía datos y los saca como una pila, esto se logra dando valores mayores que cero a type en la función msgrcv. //cola1.c #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #define BUFSZ 512 /* estructura del mensaje*/ struct msg long msg_type; char msg_text[bufsz]; pmsg; /*puntero a la estructura de mensaje*/ main(int argc, char *argv[]) int qid; /*identificador de la cola */ key_t key; /*clave de la cola */ int cont=0,len; /*el tamaã±o de los datos enviados*/ int cont2; long etiq; //creando la llave de la cola de mensaje key=ftok("hola",'h'); //crea la cola */ if((qid=msgget(key, IPC_CREAT 0666))<0) perror("msgget:create"); exit(exit_failure); printf("creado ID de cola = %d \n ",qid); printf("para terminar el envio de mensajes enter\n"); for(;;) printf("mensaje a enviar: -> "); fgets((&pmsg)->msg_text, BUFSZ, stdin); len=strlen(pmsg.msg_text); if(len==1) puts("fin de envio"); break; cont++; /*asocia el mensaje con este proceso*/ pmsg.msg_type=cont; msgsnd(qid, &pmsg,len,0); printf("etiqueta -> %d mensaje -> %s enviado \n",cont,pmsg.msg_text); cont2=cont; for(;;)
32 if(cont2==0) msgctl(qid,ipc_rmid,null); printf("\n cola %d eliminada \n ",qid); exit(exit_success); msgrcv(qid, &pmsg,bufsz,cont2,0); printf("mensaje -> %s ",(&pmsg)->msg_text); cont2--;
33 Otra modificación que se puede realizar es poner todas las etiquetas (type) con números negativos y se volverá a comportar como una pila. La cola creada y conociendo su ID se pueden conectar varios proceso sin tener ancestros en común, o también generar varias colas y conectarse a ellas, el ejemplo siguiente crea dos colas de mensajes y simula como dos cajas de un súper mercados, al final del día saca el total de la venta del día. //colas.c #include <stdio.h> #include <stdlib.h> #include <sys/msg.h> #include <string.h> #include <time.h> int nfork (int np) int i; for (i=1;i<=np;i++) if (fork()==0) return(i); return(0); struct men long menid; char nom[10]; int dato; pmen; main (void) int cid1,cid2,pid=0,i,total1=0,total2=0,total=0; int cont=1; key_t key1,key2; key1=1020; key2=2400; cid1=msgget(key1,ipc_creat 0666); cid2=msgget(key2,ipc_creat 0666); pid=nfork (2); switch (pid) case 0: //printf ("Padre \n"); for(i=0;i<2;i++)wait(&i); printf("productos caja uno \n"); for (i=0;i<5;i++) msgrcv (cid1, &pmen, sizeof(pmen), 0,0); printf("%s %d \n",pmen.nom,pmen.dato);
34 total1+=pmen.dato; printf ("Total caja uno : %d \n",total1); msgctl (cid1,ipc_rmid,null); printf("\n"); printf("productos caja dos \n"); for (i=0;i<3;i++) msgrcv (cid2, &pmen, sizeof(pmen), 0,0); printf("%s %d \n",pmen.nom,pmen.dato); total2+=pmen.dato; printf ("Total caja dos : %d \n",total2); msgctl (cid2,ipc_rmid,null); printf ("\nventa del dia= %d \n",total1+total2); exit (0); case 1: //printf ("Hijo 1 \n"); srand(getpid()); printf ("producto registrado en caja 1 \n"); for (i=0;i<5;i++) total=(1+rand()%50); printf ("producto registrado en caja 1 \n"); pmen.menid=total; pmen.dato=total; sprintf(pmen.nom,"producto-%d",cont); msgsnd (cid1,&pmen,sizeof(pmen), 0); cont++; exit (0); case 2: //printf ("Hijo 2 \n"); srand(getpid()); for (i=0;i<3;i++) total=(1+rand()%50); printf ("producto registrado en caja 2\n"); pmen.menid=total; pmen.dato=total; sprintf(pmen.nom,"producto-%d",cont); msgsnd (cid2,&pmen,sizeof(pmen), 0); cont++; exit (0); default: printf ("Error al crear procesos \n"); exit (0);
35
36 Sockets Es un mecanismo que comunica dos proceso, que pueden intercambiar diferente tipos de datos ya sea que los procesos estén corriendo en un computadora o en un red de computadoras, además guarda cierta similitud con las tuberías (pipe). Para que la comunicación se establezca entre los procesos es necesario los siguientes aspectos: Una dirección IP, un protocolo y un número de puerto. Para conseguir esto aparece el concepto de conector o socket: dos procesos distintos crean cada uno su conector por lo tanto. 1. Cada conector esta ligado a una dirección. 2. Un proceso puede enviar información, a través de un socket propio, al socket de otro proceso, siempre y cuando conozca la dirección asociada (la del otro socket). La comunicación se realiza entre una pareja de sockets. Dominios y direcciones Definimos un dominio de comunicación como una familia de protocolos que se pueden emplear para conseguir el intercambio de datos entre sockets. Un sistema UNIX particular puede ofertar varios dominios, aunque los más habituales son estos dos: 1. Dominio UNIX (PF 1 _UNIX) Para comunicarse entre procesos dentro de la misma máquina. 2. Dominio Internet(PF_INET). Para comunicarse entre procesos en dos computadoras conectadas mediante los protocolos de Internet (TCP-UDP/IP). Además un sockets del dominio PF_UNIX no puede dialogar con sockets del dominio PF_INET. Cada familia de protocolos define una serie de convenciones a la hora de especificar los formatos de las direcciones. Tenemos, por lo tanto, estas dos familias de direcciones: 1. Formato UNIX(AF 2 _UNIX). Una dirección de socket es como nombre de fichero(pathnmae). 1 PF significa Protocol Family 2 AF significa una Address Family
37 2. Formato Internet(AF_INET). Una dirección de sockets precisa de estos tres campos: a) Una dirección de red de la maquina (Dirección IP). b) Un protocolo (TCP o UDP) y c) Un puerto correspondiente a ese protocolo. Es importante resaltar que un socket puede ser referenciado desde el exterior solo si su dirección es conocida. Sin embargo, se puede utilizar un socket local aunque no se conozca la dirección que tiene. Estilos de comunicación Orientados a conexión:- Mecanismo que sirven para conseguir un canal para el intercambio de octenos. Un proceso pone, a su ritmo, bytes en el canal, que recibe de forma fiable y ordenada en el otro extremo, donde hay un proceso que los recoge a su conveniencia. Ejemplo: pipes y los socketpairs Comunicación sin conexión:- también denominada comunicación con datagramas. El emisor envía mensajes envía un mensaje autónomo que el receptor debe recibir enteros. Por el camino algún mensajes pueden perderse, retrasarse o llegar desordenados. La comunicación entre dos sockets puede realizarse con cualquiera de estas dos formas (aunque los dos sockets comunicantes deben de hacerse creados con el mismo estilo, ademas de el mismo dominio). Para ello, al crear un socket se indica el estilo de comunicación correspondiente: SOCK_STREAM la comunicación pasa por tres fases 1. Apertura de conexión 2. Intercambio de datos 3. Cierre de conexión El intercambio de datos es fiable y orientado a octenos (como los pipes): no hay frontera de mensajes SOCK_DGRAM. No hay conexiones. Cada mensaje (o datagrama) es autocontenido. Los datagramas no se mezclas se mezclan unos con otros. No hay garantia de entrega: se pueden perder, estropear o desordenar.
38 Protocolos Un protocolo es un conjunto de reglas, formato de datos y convenciones que es necesario respetar para conseguir la comunicacion entre dos entidades, ejemplos: IP, TCP, UDP, FTP, ETC., Cuando se crea un socket es necesario indicar cual es el protocolo de trasporte a emplear para el intercambio de datos que se realizara a traves de el. La mayoría de las aplicaciones con socket de tipo INTERNET trabjan bajo el paradigma cliente servidor el proceso se da de la forma siguiente: Operaciones del servidor operaciones cliente Crea un socket Anclar a un puerto Escuchar a través del puerto y definir cola de peticiones Crea un socket Aceptar la conexión Conectarse al puerto del servidor Leer/Escribir en la conexión Leer/Escribir en la conexión Cerrar la conexión Cerrar la conexión
39 Llamadas de sistemas para la creación y uso de sockets Creación de socket Un proceso puede crear un socket utilizando la función socket(). Su prototipo es este: #include <sys/types.h> #include <sys/socket.h> int socket(int domain, int type, int protocol); protocolo sirve para especificar el protocolo de comunicación a emplear, en general este argumento es 0, indicando que se usa el protocolo por omisión. Asociar el socket a un puerto: bind() Una vez creado el socket necesitamos anclarlo a un puerto para que el proceso tenga que escuchar atreves de ese puerto. Y se hace utilizando la llamada del sistema bind(). int bind(int nomsocket, const struct sockaddr *dirsocket, size_t dirsocket_longitud) Donde: nomsocket dirsocket dirsocket_longitud Socket creado a partir de la llamada bind() Contiene todos los datos asociados a una dirección donde se va a trasmitir a través del socket Contiene el tamaño de la direccion bind() regresa 0 si tuvo éxito, en caso contrario -1 que indica que existe un error Escuchando en el puerto: listen() Una vez creado, anclado a un puerto, es momento de ponerse a escuchar y s utiliza llamada del sistemas listen(). Int listen(int nomsocket, int num_max_proc)
40 Donde: nomsocket Num_ma_proc Socket creado a partir de la llamada bind() Número máximo de procesos en espera listen() regresa 0 si tuvo éxito, en caso contrario -1 que indica que existe un error Aceptando una llamada: accept() En protocolos orientados a comunicación el servidor debe esperar una petición de conexión para crear un canal de comunicación a través del cual se dará el envió y recepción de datos entre procesos. Se utiliza la llamada del sistema accept(). int accept(int nomsocket, struct sockaddr *ctladdr, int *addrlen) Donde: nomsocket ctladdr addrlen Descriptor del socket Dirección del proceso con el que se estableció el canal de comunicación (cliente) Longitud de la dirección accept() regresa 0 si tuvo éxito, en caso contrario -1 que indica que existe un error. Conectándose al puerto: connect() Esta llamada de sistema es usada por el cliente para solicitar una conexión al servidor. int connect(int nomsocket, struct sockaddr *servaddr, int *addrlen) Donde: nomsocket ctladdr addrlen Descriptor del socket Dirección del servidor Longitud de la dirección connect() regresa 0 si tuvo éxito, en caso contrario -1 que indica que existe un error. Recepción de mensajes: read(), recv() y recvfrom() Enviando mensajes: write(), send() y sendto() Cerrando la comunicación: close()
41 Comunicación con socketpairs Este mecanismo es muy similar a las tuberías solo que con la particularidad de que son bidireccionales y solos son usados cuando los procesos tienen un ancestro en común. Para creas un socketpairs se hace de la siguiente función: #include <sys/types.h> #include <sys/socket.h> Int socketpair(int domain, int type, int protocolo, int vecsock[2]
42 Las tareas que se deben realizar se muestran en la siguiente tabla PADRE HIJO Crear un socketpair Crear el hijo Leer un mensaje Escribir un mensaje Terminar Escribir un mensaje Leer un mensaje Terminar Ejemplo: //sockepair.c #include <sys/types.h> #include <sys/socket.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #define men1 "papa esta ahi" #define men2 "aqui estoy hijo" main() int n,sockets[2], child; char buf[1024]; if(socketpair(pf_unix,sock_stream,0,sockets)<0) perror("abriendo el par de sockets\n"); exit(1); if ((child=fork())==-1) perror("creando el proceso hijo\n"); else if(child) //este es el padre close(sockets[0]); if(read(sockets[1],buf,1024)<0) perror("padre leyendo el mensaje \n"); printf("id padre = %d mensaje de mi hijo --> %s \n",getpid(),buf); if(write(sockets[1],men2,strlen(men2)+1)<0) perror("padre escribiendo el mensaje"); printf("id padre = %d respuesta --> %s \n",getpid(),men2); close(sockets[1]); exit(1); else /*este es el hijo */ close(sockets[1]);
43 printf("id hijo = %d pregunta --> %s\n",getpid(),men1); if(write(sockets[0],men1,strlen(men1)+1)<0) perror("hijo escribiendo mensaje"); wait(&n); if(read(sockets[0],buf,1024)<0) perror("hijo leyedo mensaje\n"); printf("id hijo = %d respuesa de papa--> %s\n",getpid(),buf); close(sockets[0]); Datagrama en el dominio UNIX Para ejemplificar utilizaremos dos programas uno que actuara como emisor y otro como receptor, la tarea del emisor es enviar un mensaje al receptor y el receptor la recibe y muestra el mensaje. //receptor sock-dgram-receptor.c //Ejemplo sobre data gramas en el dominio PF_UNIX //extremo receptor //proceso para el intercambio de información //1.- ejecutamos el receptor //2.- Ejecutar el emisor #include <sys/types.h> #include <sys/socket.h> #include <sys/un.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #define NAME "socketunix" main() int sock, length, lon2; struct sockaddr_un name; char buf[1024]; sock=socket(pf_unix, SOCK_DGRAM,0);
44 if(sock<0) perror("abriendo socket de dtagramas"); exit(1); name.sun_family=af_unix; strcpy(name.sun_path,name); if(bind(sock,(struct sockaddr *)&name,sizeof(name))<0) perror("asociado con nombre al socket"); exit(1); printf("direccion del socket -> %s \n",name); if(recvfrom(sock,buf,1024,0,null,&lon2)<0) perror("recibiendo un datagrama"); printf("id proceso %d --> %s\n",getpid(),buf); close(sock); unlink(name); exit(0); // Emisor sock-dgram-emisor.c //ejemplo sobre datagrama en el dominio PF_UNIX //Extremo Emisor #include <sys/types.h> #include <sys/socket.h> #include <sys/un.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #define DATA "emisor esta ahiiiiiiiiiii" main(int argc, char *argv []) int sock; struct sockaddr_un name; sock=socket(pf_unix, SOCK_DGRAM,0); if(sock<0) perror("abriendo scoket de datagrama"); exit(1); name.sun_family=af_unix; strcpy(name.sun_path,argv[1]); printf("id proceso %d pregunta: --> %s\n",getpid(),data); if(sendto(sock,data,strlen(data)+1,0,(struct sockaddr *)&name,sizeof name)<0) perror("enviando un datagrama"); close(sock); exit(0);\
45
46 Socket tipo INTERNET en modo comunicación Conexión simultaneas Consiste en crear aplicaciones concurrentes bajo el esquema cliente-servidor, en este caso creamos un servidor multiprocesos, el proceso principal crea procesos hijos los cuales se les asigna una la tarea de atender la petición de algún servidor os sea cada servidor le corresponde un proceso hijoi(i) /*Serveco3.c : Un servidor de eco orientado a conexión concurrente*/ /* multiproceso basado en sockets.*/ #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include<signal.h> #include <errno.h> /* */ void do_echo(int); /* */ extern int errno; /* */ void do_echo(int fd) char buf[4096],resp[100]; int cc,org,faltan,cc2,opc; //read(int fd, void *buf, size_t nbyte); //fd descriptor del socket(ssocket) //buf almacena la lectura //sizeof(buf) tamaño de buf while (cc=read(fd,buf,sizeof(buf))) if (cc<0) perror("read"); exit(6); //printf("buf %s opc=%d \n",buf,opc); //printf("lect-> %s longitud %d \t",buf,strlen(buf)); switch(buf[0]) case '0':strcpy(resp,"number zero\n"); break; case '1':strcpy(resp,"number one\n"); break; case '2':strcpy(resp,"number two\n"); break; default: strcpy(resp,"fuera de rango[0,2]\n"); break; org=0;
47 faltan=strlen(resp); /*Los que hay que mandar*/ //write(int fd, void *buf, size_t nbyte); while (faltan) /// if ((cc2=write(fd,&resp[org],faltan))<0) perror("fallo al escribir"); exit(7); org+=cc2; faltan-=cc2; close(fd); /* */ int main() struct sockaddr_in sin,fsin; int s,ssock,alen;//read(int fd, void *buf, size_t nbyte); sin.sin_family=af_inet; sin.sin_addr.s_addr =htonl(inaddr_any); sin.sin_port =htons(4000); //crea socket //s=/-1 entonces error if ((s=socket(pf_inet,sock_stream,0))<0) perror("no se puede crear el socket"); exit(1); //asocia el socket a un puerto los datos se dant //en los campos de la estructura sin if (bind (s,(struct sockaddr *)&sin,sizeof(sin))<0) perror("no se puede asignar la dirección"); exit(2); //escucha s id-sock, 5 el numnero max de proceso en espera if (listen(s,5)<0) perror("no puedo poner el socket en modo escucha"); exit(3); signal(sigchld, SIG_IGN); while (1) alen=sizeof(fsin); //acepta o se emite mensajes //*fsin direccion en donde el proceso establecio el canal de comunicacion el cliente //*alen longitud de la direccion if ((ssock =accept(s, (struct sockaddr *)&fsin,&alen))<0) if (errno == EINTR) continue; perror("fallo en funcion accept"); exit(4); switch (fork())
48 case -1: perror("no puedo crear hijo"); exit(5); case 0 : close(s); /*Proceso hijo*/ do_echo(ssock); break; default: close(ssock); break;
49 Bibliografia TCP/IP en Unix programación de aplicaciones distribuidas Jose Miguel Alonso RA-MA
Redes de Computadores: Relación de problemas 1. Sockets
Redes de Computadores: Relación de problemas 1. Sockets 1. Obtención de nombres y direcciones IP Uso de gethostbyname y gethostbyaddr. Bajo el sistema operativo Linux, esta información se puede obtener
Más detalles-> Todo socket viene definido por dos características fundamentales:
LOS SOCKETS. Los sockets no son más que puntos o mecanismos de comunicación entre procesos que permiten que un proceso hable (emita o reciba información) con otro proceso incluso estando estos procesos
Más detallesSockets (TCP) Tema 2.- Nivel de aplicación en Internet
Sockets (TCP) Tema 2- Nivel de aplicación en Internet Dr Daniel Morató es de Computadores Ingeniero Técnico en Informática de Gestión, 2º curso Material parcialmente adaptado del libro Computer Networking:
Más detallesIntroducción a la programación con sockets en C
Introducción a la programación con sockets en C Enrique Bonet Departamento de Informática Universidad de Valencia Índice Introducción Socket Creación de un socket Cierre de un socket Asociación de un socket
Más detallesRedes de Computadores Nivel de Aplicación: Programación con sockets I
Redes de Computadores Nivel de Aplicación: Programación con sockets I Área de Ingeniería Telemática Dpto. Automática y Computación http://www.tlm.unavarra.es/ En clases anteriores... El nivel de aplicación
Más detallesUNIVERSIDAD DE CANTABRIA DEPARTAMENTO DE INGENIERÍA DE COMUNICACIONES GRUPO DE INGENIERÍA TELEMÁTICA
UNIVERSIDAD DE CANTABRIA DEPARTAMENTO DE INGENIERÍA DE COMUNICACIONES GRUPO DE INGENIERÍA TELEMÁTICA MANUAL DE SOCKETS EN C TABLA DE CONTENIDOS Introducción.. 4 Sockets en C.. 7 2.1 Conceptos Básicos..
Más detallesEstructuras y funciones de programación de sockets.
Estructuras y funciones de programación de sockets. Introducción. En estos apuntes se incluye una breve descripción de las estructuras y funciones cuyo uso puede ser necesario para el desarrollo de las
Más detallesArquitecturas Cliente/Servidor
Arquitecturas Cliente/Servidor Integrantes: Arellano Santiago Víctor Manuel Girón Capistrán Aldo Iván Guerrero Ramirez Eduardo Daniel Rosas Peña Ramiro SOCKETS EN C. LLAMADAS PARA EL MANEJO DE SOCKETS
Más detallesMigrando aplicaciones a IPv6
Migrando aplicaciones a Fundamentos técnico: DualStack y Socket.h Alonso Sandoval A. Hernán Vargas L. Universidad Técnica Federico Santa María asandova@alumnos.inf.utfsm.cl, hvargas@alumnos.inf.utfsm.cl
Más detallesMecanismos IPC: sockets
Mecanismos IPC: sockets Ampliación de Sistemas Operativos (prácticas) E.U. Informática en Segovia Universidad de Valladolid Sockets Los sockets son una abstracción lógica que permiten la comunicación bidireccional
Más detallesSistemas Operativos: Programación de Sistemas. Curso Oscar Déniz Suárez Alexis Quesada Arencibia Francisco J.
Tema 5 : Comunicación entre Procesos mediante Tuberías Sistemas Operativos: Programación de Sistemas Oscar Déniz Suárez Alexis Quesada Arencibia Francisco J. Santana Pérez Curso 2006-07 Introducción Algunas
Más detallesSockets: funcionamiento y programación. Sockets tipo UNIX. MSc. Ivan A. Escobar
Sockets tipo UNIX MSc. Ivan A. Escobar Creación socket: socket() int socket(familia, tipo, protocolo) Regresa un valor entero Parecido descriptor de archivos: descriptor socket sockfd int familia familia
Más detallesDesarrollo de Aplicativos con winsockets
Seminario de Redes de Computadoras 66.48 Desarrollo de Aplicativos con winsockets Docentes: Ing. Marcelo Utard Ing. Pablo Ronco Alumnos: Baños, Germán Gámez, Pablo Rabino, Juan Pablo Salas, Federico Introducción
Más detallesProblemas de Redes de Computadores. Ingeniería Técnica en Informática de Gestión Conjunto de problemas 1
Problemas de Redes de Computadores. Ingeniería Técnica en Informática de Gestión Conjunto de problemas 1 Preguntas cortas Pregunta 1.1: Si configuro mi servidor Web para que no acepte conexiones desde
Más detallesProblemas de Redes de Computadores. Conjunto de problemas 1
Problemas de Redes de Computadores. Ingeniería Técnica en Informática de Gestión Conjunto de problemas 1 Pregunta 1.1: Si configuro mi servidor Web para que no acepte conexiones desde la dirección IP 130.206.1.1,
Más detallesSistemas Operativos Distribuidos
Sockets Sistemas Distribuidos Sockets Aparecieron en 1981 en UNIX BSD 4.2 Intento de incluir TCP/IP en UNIX. Diseño independiente del protocolo de comunicación. Un socket es punto final de comunicación
Más detallesEstructuras y funciones de programación de sockets.
Estructuras y funciones de programación de sockets. Introducción. Autor: Enrique Bonet En estos apuntes se incluye una breve descripción de las estructuras y funciones cuyo uso puede ser necesario para
Más detallessockets Flujo (SOCK_STREAM) Comunicación bidireccional Confiable (entrega garantizada) Información ordenada en el destino Datagrama (SOCK_DGRAM)
s s Comunicación punto-a-punto entre procesos Los s son los extremos de la comunicación Diferentes dominios UNIX: Entre procesos de un mismo equipo Internet: Entre procesos de diferentes equipos (TCP/IP)
Más detallesSistemas Operativos Practica 1: procesos y concurrencia.
Sistemas Operativos Practica 1: procesos y concurrencia. Objetivos: Introducir al alumno a los conceptos de programa, concurrencia, paralelismo y proceso o tarea. Manejo del concepto de concurrencia haciendo
Más detallesIntroducción a Sockets en Linux
Introducción a Sockets en Linux Horacio Goetendía Bonilla 6 de Enero de 2003 Índice 1. Conceptos 2 1.1. Socket............................... 2 2. Sockets en Unix standar 2 2.1. Namespace (int dominio)(dominio
Más detallesUNIVERSIDAD AUTÓNOMA DE BAJA CALIFORNIA FACULTAD DE CIENCIAS PRACTICA DE PROCESOS HERRAMIENTAS
UNIVERSIDAD AUTÓNOMA DE BAJA CALIFORNIA FACULTAD DE CIENCIAS PRACTICA DE PROCESOS HERRAMIENTAS Caso 1: 1.- Necesitamos un cd o Dvd para grabar alguna de las versiones de livecd de Linux. 2.- Liga de una
Más detallesIntroducción de Sockets en C.
PRÁCTICA 2: Introducción de Sockets en C. 1 La Interfaz Socket es una API para redes TCP/IP que se compone de funciones o rutinas. Originalmente se construyó a principios de los 80 para el sistema operativo
Más detallesSockets (UDP) Tema 2.- Nivel de aplicación en Internet
Sockets (UDP) Tema 2.- Nivel de aplicación en Internet Dr. Daniel Morató es de Computadores Ingeniero Técnico en Informática de Gestión, 2º curso Sockets y UDP UDP: no hay conexión entre cliente y servidor»
Más detallesCOMUNICACIÓN ENTRE PROCESOS SOCKETS
COMUNICACIÓN ENTRE PROCESOS SOCKETS Diseño de Sistemas Operativos Curso 2007/08 Grupo: Mi30 Martín Santana, A. David Martínez Santana, Luis Ignacio Qué son?(definición) n) Los sockets son mecanismos de
Más detallesQué es un socket? Dominios de comunicación. Tipos de sockets en el dominio AF_INET. Sockets Stream. Sockets Datagram. Sockets Raw
Qué es un socket? Es una interfaz de entrada salida de datos que permite la intercomunicación entre procesos. Los procesos pueden estar ejecutándose en el mismo o en distintos sistemas, unidos mediante
Más detallesSistemas Operativos: Programación de Sistemas. Curso 2006-07. Oscar Déniz Suárez Alexis Quesada Arencibia Francisco J.
Tema 7 : Comunicación mediante sockets Sistemas Operativos: Programación de Sistemas Oscar Déniz Suárez Alexis Quesada Arencibia Francisco J. Santana Pérez Curso 2006-07 Introducción Los sockets (también
Más detallesTEMA 3. CONCEPTOS FUNDAMENTALES DEL NIVEL DEL SISTEMA OPERATIVO. Definición y objetivos de un S.O
TEMA 3. CONCEPTOS FUNDAMENTALES DEL NIVEL DEL SISTEMA OPERATIVO Definición y objetivos de un S.O Definición y objetivos del sistema operativo Estructura, componentes y servicios de un S.O Llamadas al sistema
Más detallesSistemas Operativos I. Enxeñería Informática. Curso 2007/08. Práctica 2: Concurrencia de procesos: Productores/Consumidores.
Sistemas Operativos I. Enxeñería Informática. Curso 2007/08. Práctica 2: Concurrencia de procesos: Productores/Consumidores. En esta práctica se tratará de resolver el problema de los productores/consumidores
Más detallesCaracterísticas de un lenguaje ideal para robótica
COMUNICACIÓN MEDIANTE SOCKETS Enrique Ortega Edrodoso Ingeniería Técnica de Informática de Gestión Introducción Los vehículos autoguiados comerciales disponibles en la actualidad tienen una serie de inconvenientes
Más detallesARQUITECTURA DE REDES Laboratorio
1nsloo.cl ARQUITECTURA DE REDES Laboratorio Práctica 4: Ejercicios de aplicación de HTTP 1. OBJETIVOS. El objetivo de esta práctica es que el alumno llegue a conocer los principales conceptos relacionados
Más detallesARQUITECTURA DE REDES Laboratorio PRÁCTICA 2: MANUAL DE SOCKETS EN C. Grado en Ingeniería Informática Curso 2014/15
ARQUITECTURA DE REDES Laboratorio PRÁCTICA 2: MANUAL DE SOCKETS EN C Grado en Ingeniería Informática Curso 2014/15 ÍNDICE 1. INTRODUCCIÓN.. 3 1.1 La familia de protocolos TCP/IP. 3 1.2 Nivel de red (IP)..
Más detallesMecanismos IPC System V
Mecanismos IPC System V Ampliación de Sistemas Operativos (prácticas) E.U. Informática en Segovia Universidad de Valladolid Mecanismos IPC System V: generalidades (1) Existen tres tipos de mecanismos IPC
Más detallesProcesos e Hilos en C
Procesos e Hilos en C 6 de febrero de 2012 En esta sesión vamos a escribir programas en lenguaje C que utilicen hilos y procesos para comparar el rendimiento del sistema ante la gestión de unos y otros.
Más detallesDiseño de aplicaciones distribuidas ÍNDICE
Aplicaciones Distribuidas (s) Aplicaciones Distribuidas (s) TCP TCP Protocolos de Protocolos de Transporte Transporte UDP UDP STREAM STREAM (TCP) (TCP) SOCKET SOCKET Etapas en la Creación Etapas en la
Más detallesIPC SYSTEM V. Técnicas Digitales III Ing. Gustavo Nudelman 2011. Universidad Tecnológica Nacional - Facultad Regional Buenos Aires
IPC SYSTEM V Técnicas Digitales III Ing. Gustavo Nudelman 2011 IPC System V En la década del 70, se incorpora a Unix una gran cantidad de funcionalidades llamadas System V entre las cuales aparecen tres
Más detallesUniversidad Simón Bolívar Departamento de Computación y Tecnología de la Información Curso de Redes I CI-4815 Trimestre Septiembre Diciembre 2013
Universidad Simón Bolívar Departamento de Computación y Tecnología de la Información Curso de Redes I CI-4815 Trimestre Septiembre Diciembre 2013 Proyecto I Autores: Lairon Acosta. Carnet: 09-10927 Jueves
Más detallesPRÁCTICA 2: Cliente-servidor UDP
PRÁCTICA 2: Cliente-servidor UDP El objetivo de esta práctica es la familiarización con aplicaciones elementales que usan los servicios de transporte de los sockets UDP. A lo largo de la práctica se realizarán
Más detallesSockets. Los sockets son un mecanismo de comunicación entre procesos que se utiliza en Internet.
Sockets La biblioteca estándar de clases de Java nos proporciona todo lo que necesitamos para utilizar sockets en nuestras aplicaciones en el paquete java.net, por lo que tendremos que añadir la siguiente
Más detallesProgramación C/S Básica
1 de 16 Programación C/S Básica Enrique Alba Torres Universidad de Málaga (UMA) 2 de 16 Los servicios Internet se ofertan como sistemas Cliente/Servidor Los protocolos de base suelen ser peer-to-peer (igual-a-igual)
Más detallesIngeniería Técnica de Telecomunicación, esp. Telemática Universidad de Jaén
Contenido. Introducción Primitivas Sockets orientadas a conexión (TCP) Primitivas orientadas a no conexión (UDP) Programación con Sockets en Internet Funciones sockets Funciones auxiliares 1 Bibliografía.
Más detallesRedes (IS20) Ingeniería Técnica en Informática de Sistemas - (2º Curso)
Redes (IS20) Ingeniería Técnica en Informática de Sistemas - (2º Curso) Práctica 2: Programación en Red. Protocolos TCP y UDP. Comunicación entre procesos mediante Sockets Descripción del equipo: 1. Ordenadores
Más detallesElementos de un programa en C
Elementos de un programa en C Un programa en C consta de uno o más archivos. Un archivo es traducido en diferentes fases. La primera fase es el preprocesado, que realiza la inclusión de archivos y la sustitución
Más detallesProgramación con Sockets
Programación con Sockets INTRODUCCIÓN 1 Qué son los Sockets? Son un mecanismo de comunicación entre procesos: Dentro de una misma máquina. Distribuidos en diferentes máquinas. Que pueden ser identificados
Más detallesSistema Cliente Servidor Con Sockets
Sistema Cliente Servidor Con Sockets Rafael Benedicto Tovar Antonio Soler Muñoz 0 Índice 1. Resumen del proyecto 2 Introducción teórica 2.1 - Qué es un socket? 2.2 - Dominios de comunicación 2.3 - Tipos
Más detallesTema 4: Sockets: Un interfaz con TCP/IP
Tema 4: Sockets: Un interfaz con TCP/IP Introducción. Conceptos básicos. Dirección de un socket. Llamadas básicas de los sockets. Diferencias entre BSD-Sockets y WinSockets. Asignación de puertos a procesos.
Más detallesDESARROLLO DE APLICACIONES DISTRIBUIDAS. SOCKETS en UNIX
DESARROLLO DE APLICACIONES DISTRIBUIDAS PRÁCTICAS CURSO 2002-2003 SOCKETS en UNIX 1. Los SOCKETS en OSI/ISO - Como ya conocéis, el modelo OSI/ISO estructura los diferentes elementos que conforman una red
Más detallesSockets Básicos. Sockets Básicos
Sockets Básicos Pedro Merino Gómez Jesus Martínez Cruz Dpto. Lenguajes y Ciencias de la Computación Universidad de Málaga Sockets Básicos Temas a tratar... APIS para acceso a TCP/IP El socket como descriptor
Más detallesSistemas operativos. Hasta ahora hemos visto. Relación programa-sistema operativo Gestión de memoria
Sistemas operativos UPCO ICAI Departamento de Electrónica y Automática 1 Hasta ahora hemos visto Relación programa-sistema operativo Gestión de memoria Reserva para la ejecución Pilas, heap, memoria de
Más detallesAdaptación de aplicaciones a IPv6
Adaptación de aplicaciones a IPv6 extensión de la interfaz de sockets Eva M. Castro ecastro@dit.upm.es Tutorial IPv6 -Adaptación de aplicaciones a IPv6 1 Contenido * Introducción Modelo de sockets BSD
Más detallesSistemas Operativos Práctica 3
Sistemas Operativos Práctica 3 Ing. Andrés Bustamante afbustamanteg@unal.edu.co Ingeniería de Sistemas Facultad de Ingeniería Universidad de la Amazonia 2009 1. Objetivo El objetivo de la práctica es que
Más detalles- Bajo que condiciones el algoritmo de planifiación de procesos FIFO (FCFS) resultaría en el tiempo de respuesta promedio más pequeño?
Sistemas Operativos. Grado Ingeniería Informática. TGR-2.1 Procesos. Noviembre 2014 Problemas para hacer en clase FIFO cpu C A 1. Dos procesos A y B tienen una ráfaga de CPU de 50 ms y un proceso C tiene
Más detallesTema 13: Apuntadores en C
Tema 13: Apuntadores en C M. en C. Edgardo Adrián Franco Martínez http://www.eafranco.com edfrancom@ipn.mx @edfrancom edgardoadrianfrancom Estructuras de datos (Prof. Edgardo A. Franco) 1 Contenido Introducción
Más detallesSockets Básicos. APIS para acceso a TCP/IP. APIS para acceso a TCP/IP. APIS para acceso a TCP/IP. APIS para acceso a TCP/IP. Temas a tratar...
Sockets Básicos Pedro Merino Gómez Jesus Martínez Cruz Dpto. Lenguajes y Ciencias de la Computación Universidad de Málaga Temas a tratar... Sockets Básicos El como descriptor para E/S Funciones básicas
Más detallesRedes de Computadores Más sobre TCP. Área de Ingeniería Telemática Dpto. Automática y Computación
Redes de Computadores Más sobre TCP Área de Ingeniería Telemática Dpto. Automática y Computación http://www.tlm.unavarra.es/ En clases anteriores Nivel de transporte UDP Introducción a TCP y transporte
Más detallesClase de Sockets en lenguaje C. Prof. Ricardo González
Clase de Sockets en lenguaje C Prof. Ricardo González 1 Modelo de Programación Cliente-Servidor Cliente: un programa que envía peticiones. Servidor: un programa que ofrece un servicio que satisface peticiones
Más detallesUsando el Sistema Operativo
Sistemas Operativos Pontificia Universidad Javeriana Enero de 2010 Los sistemas operativos Los sistemas operativos Perspectivas del Computador Concepto general El sistema operativo es parte del software
Más detallesCapítulo 3: Procesos. n Concepto de Proceso. n Despacho (calendarización) de Procesos. n Operaciones en Procesos. n Procesos en cooperación
3.- Procesos Capítulo 3: Procesos Concepto de Proceso Despacho (calendarización) de Procesos Operaciones en Procesos Procesos en cooperación Compunicación Interprocesos Communicación en sistemas Cliente-Servidor
Más detallesParadigma de paso de mensajes
Paradigma de paso de mensajes Curso 2011-2012 Índice Visión lógica del paradigma de paso de mensajes. Operaciones básicas en paso de mensajes. Operaciones bloqueantes. Operaciones no bloqueantes. MPI:
Más detallesEscuela Politécnica Superior de Elche
EXAMEN DE SISTEMAS INFORMÁTICOS INDUSTRIALES ((SOLUCIÓN) (TEORÍA)jUJ jhshshs SEPTIEMBRE 2015 1. Indicar si las siguientes afirmaciones son verdaderas o falsas: (a) En C++, una clase derivada puede acceder
Más detallesTimeOut RTT medido 1 5 seg. 2*5= 10 1 2 0,7 3 TimeOut 3 TimeOut 3 0,001 4 0,35 5 0,44
ARQUITECTURA DE REDES Y SERVICIOS DE TELECOMUNICACIÓN Junio 2014 Teoría: 1) Qué sucedería si por error recibiera UDP un datagrama UDP que originalmente iba destinado a otra máquina?. (0,5 ptos) 2) Asumiendo
Más detallesProgramación de sockets
Programación de sockets Xavier Perramon Tornil Enric Peig Olivé P03/75064/00978 FUOC P03/75064/00978 Programación de sockets Índice Introducción... 5 Objetivos... 6 1. Qué son los sockets... 7 1.1. Visión
Más detallesTEMA 7: Ficheros. TEMA 7: Ficheros. 7.1.-Concepto de fichero
TEMA 7: Ficheros 7.1.-Concepto de fichero Todas las estructuras de datos que hemos visto hasta ahora utilizan memoria principal. Esto tiene dos limitaciones importantes: 1. Los datos desaparecen cuando
Más detallesTELEPROCESO Y SISTEMAS DISTRIBUIDOS
Universidad Nacional del Nordeste TELEPROCESO Y SISTEMAS DISTRIBUIDOS La Interfaz Socket Lic. Vanesa S. Roffé Año 2009 Introducción - Origen de la INTERFAZ SOCKET La Interfaz Socket es una API para redes
Más detallesPráctica 5: Implementación en C++ de sistemas cliente/servidor basados en comunicación
Práctica 5: Implementación en C++ de sistemas cliente/servidor basados en comunicación síncrona Programación de Sistemas Concurrentes y Distribuidos Grado de Ingeniería Informática Dpto. de Informática
Más detallesAnálisis Experimental de la Transmisión de Datos
UNIVERSIDAD TÉCNICA FEDERICO SANTA MARÍA DEPARTAMENTO DE ELECTRÓNICA Análisis Experimental de la Transmisión de Datos ELO322 Redes de Computadores I Pablo Ahumada D. Jorge Cápona G. Resumen Se muestra
Más detallesBibliografía [COM00] Internetworking with TCP/IP, vol. 3, Cap. 2 y del 7 al 15.
Tema 5: El Modelo Cliente-Servidor Conceptos básicos. Características y estructura de un cliente. Obtención de información. Algoritmos del cliente TCP y UDP. Ejemplos. Características y estructura de un
Más detallesLEER Y ESCRIBIR ARCHIVOS DE TEXTO CON PHP. FUNCIONES FOPEN (MODOS), FGETS, FPUTS, FCLOSE Y FEOF. EJEMPLOS (CU00836B)
APRENDERAPROGRAMAR.COM LEER Y ESCRIBIR ARCHIVOS DE TEXTO CON PHP. FUNCIONES FOPEN (MODOS), FGETS, FPUTS, FCLOSE Y FEOF. EJEMPLOS (CU00836B) Sección: Cursos Categoría: Tutorial básico del programador web:
Más detallesAPUNTADORES. Un apuntador es un objeto que apunta a otro objeto. Es decir, una variable cuyo valor es la dirección de memoria de otra variable.
APUNTADORES Un apuntador es un objeto que apunta a otro objeto. Es decir, una variable cuyo valor es la dirección de memoria de otra variable. No hay que confundir una dirección de memoria con el contenido
Más detallesProgramación con sockets
Programación con sockets Internetworking with TCP/IP Client/Server Programming and Applications: Linux/POSIX Sockets Version Douglas E. Comer David L. Stevens Capítulos: 2, 5, 7 Grupo de Sistemas y Comunicaciones
Más detallesARQUITECTURA DE REDES Laboratorio
1nsloo.cl ARQUITECTURA DE REDES Laboratorio Práctica 2: Ejercicios de aplicación de Sockets en C 1. OBJETIVOS. El objetivo de esta práctica es que el alumno llegue a conocer los principales conceptos relacionados
Más detallesNivel de Transporte en Internet
Nivel de Transporte en Internet Nivel de Transporte en TCP/ La capa de transporte transmite mensajes entre las aplicaciones de dos ordenadores. La programación de aplicaciones sobre el nivel de transporte
Más detallesSOCKET S. Alberto Castro Rojas
SOCKET S EL64E Alberto Castro Rojas 1 Interfaz de programación genérica Soporte de múltiples suites de protocolos de comunicación (familias) Representaciones de direcciones sin dependencias (endpoint)
Más detalles07 << Acceso en exclusiva al recurso compartido >>
Sistemas Operativos 4º Semestre. Grados II y MI Cuarto Parcial. Sistema de Ficheros. 2 de Junio de 2014. Dispone de 50 minutos. Publicación de notas el Jueves 5 de Junio 2014. Revisión el Viernes 6 de
Más detallesTema 5 El Modelo Cliente-Servidor
1 Tema 5 El Modelo Cliente-Servidor Capítulos: Conceptos básicos. Características y estructura de un cliente. Obtención de información. Algoritmos del cliente TCP y UDP. Ejemplos. Características y estructura
Más detallesTodo programa en 'C' consta de una o más funciones, una de las cuales se llama main.
LENGUAJE C CARACTERISTICAS DEL LENGUAJE 'C' El lenguaje 'C' se conoce como un lenguaje compilado. Existen dos tipos de lenguaje: interpretados y compilados. Los interpretados son aquellos que necesitan
Más detallesIMPLEMENTACIÓN DE APLICACIONES DE SEGURIDAD CON OPENSSL
IMPLEMENTACIÓN DE APLICACIONES DE SEGURIDAD CON OPENSSL Índice Lectura de Certificados con OpenSSL I Proyecto Leer_certificado1 Lectura de Certificados con OpenSSL II Proyecto Leer_certificado2 Proyecto
Más detallesCUESTIONARIO PARA EL PROTOCOLO TCP/IP PREGUNTAS
CUESTIONARIO PARA EL PROTOCOLO TCP/IP PREGUNTAS TEMA I 1. - Qué significa TCP/IP? 2. - Por que es necesario usar TCP/IP? 3. - Cuáles son algunas funciones del nivel de aplicación? 4. - Qué es una PDU?
Más detallesAdministración de redes en GNU/Linux
Administración de redes en GNU/Linux La configuración de una red en UNIX/Linux es en cierta medida más compleja que en sistemas Microsoft. Sin embargo para numerosos administradores tiene un mayor grado
Más detallesComputación de Alta Performance Curso 2009 PROGRAMACIÓN PARALELA EN LENGUAJE C
Computación de Alta Performance Curso 2009 MECANISMO DE PROGRAMACIÓN PARALELA EN LENGUAJE C AGENDA Mecanismos a estudiar. Fork. Pipes y FIFOs. System V IPC: Semáforos. Cola de mensajes. Memoria compartida.
Más detallesLo guardamos como prog.c, lo compilamos y lo ejecutamos en la máquina tlm14 obteniendo el siguiente resultado:
Nomenclatura: En todas las cuestiones la dirección IP de un router llamado RX configurada en su interfaz número y lo indicaremos con IPRX,ify y la dirección MAC de ese interfaz, caso de ser Ethernet, con
Más detallesProgramación. Test Autoevaluación Tema 3
Programación Test Autoevaluación Tema 3 Autores: M. Paz Sesmero Lorente Paula de Toledo Heras Fco. Javier Ordoñez Morales Juan Gómez Romero José A. Iglesias Martínez José Luis Mira Peidro SOLUCIONES 1.
Más detallesProgramación de aplicaciones distribuidas usando sockets
Programación de aplicaciones distribuidas usando sockets 1 a Versión: José Luis Díaz. Octubre 1994. 2 a Versión: José Ramón Arias. Nov. 1998, Oct. 1999, Oct. 2000. Índice general 1. Programación de aplicaciones
Más detallesManipulación de procesos
Manipulación de procesos Las primeras computadoras solo podían manipular un programa a la vez. El programa tenía control absoluto sobre todo el sistema. Con el desarrollo vertiginoso del hardware ese panorama
Más detallesSeguridad en el Sistema de Archivos. Dr. Alonso Ramírez Manzanares 23-Nov-2010
Seguridad en el Sistema de Archivos Dr. Alonso Ramírez Manzanares 23-Nov-2010 Seguridad La protección de la información es algo muy valioso, la información es una moneda en si. Esto va muy asociado a los
Más detallesPráctica 1: sockets en Python
Práctica 1: sockets en Python Álvaro Navarro anavarro@gsyc.es Jesús M. González-Barahona jgb@gsyc.es Infraestructura de Redes 5 o Ingeniería Informática 08/09 1. Fase 1: Cliente UDP Esta primera fase tiene
Más detallesModem IBM Compatible. IBM Compatible. Ethernet IBM AS/400. Laser printer. Workstation. Mac II. El Interfaz. Socket. versión perliminar
IBM Compatible Modem IBM Compatible Ethernet IBM AS/400 Laser printer Workstation Mac II El Interfaz Socket versión perliminar ÍNDICE 1. INTRODUCCIÓN. 2. QUÉ ES UN SOCKET?. 2.1. Dominio de un socket. 2.2.
Más detallesSOCKETS en Linux. Lic. Leonardo de - Matteis. Departamento de Ciencias e Ingeniería de la Computación Universidad Nacional del Sur 2011
Introducción al uso de SOCKETS en Linux Lic. Leonardo de - Matteis Departamento de Ciencias e Ingeniería de la Computación Universidad Nacional del Sur 2011 Interfaz de programación de aplicaciones NAPI
Más detallesArquitectura de Redes y Servicios de Telecomunicación
Práctica 3 Arquitectura de Redes y Servicios de Telecomunicación Programación cliente/servidor: Servicio de echo. Desarrollo de un cliente y un servidor del servicio de echo. Objetivos La programación
Más detallesCurso de Programación en C. Licenciatura, FCQeI. APUNTADORES.
APUNTADORES. La memoria de una máquina esta ordenada en forma de celdas numeradas consecutivamente y que se pueden manipular individualmente o en grupos contiguos. La siguiente figura muestra una representación
Más detallesApuntadores (Punteros)
Apuntadores (Punteros) x9ff10 X int 209 SESION 7 *ptr Definición Llamados también punteros. Un Apuntador es una variable que contiene una dirección de memoria, la cual corresponderá a un dato o a una variable
Más detallesBloque III: El nivel de transporte. Tema 6: Conexiones TCP
Bloque III: El nivel de transporte Tema 6: Conexiones TCP Índice Bloque III: El nivel de transporte Tema 6: Conexiones TCP Establecimiento de conexión Finalización de conexión Diagrama de estados Segmentos
Más detallesProgramación estructurada (Introducción a lenguaje C)
Programación estructurada (Introducción a lenguaje C) M. en C. Sergio Luis Pérez Pérez UAM CUAJIMALPA, MÉXICO, D. F. Trimestre 15-I Sergio Luis Pérez (UAM CUAJIMALPA) Curso de programación estructurada
Más detallesSistemas Operativos. Contents. Ezequiel Postan. Docentes. Guido Macchi. Esteban Ruiz. Federico Bergero. Guillermo Grimgblat
Sistemas Operativos Ezequiel Postan Docentes Abstract Apuntes de la materia Sistemas Operativos de LCC-FCIEA. Curso dictado en 2011. El apunte está basado en la carpeta Emilio Lopez con agregados y correcciones.
Más detallesSOLUCION EXAMEN junio 2006
SOLUCION EXAMEN junio 2006 1. Explique razonadamente si las siguientes afirmaciones son verdaderas o falsas: I) (1 p) En UNIX únicamente se distinguen dos tipos de procesos: los procesos de usuario y los
Más detallesTema ADQUISICIÓN Y TRATAMIENTO DE DATOS. Departamento de Ciencias de la Computación e IA. Subprogramas en C
Tema ADQUISICIÓN Y TRATAMIENTO DE DATOS Departamento de Ciencias de la Computación e IA Subprogramas en C Objetivo Una vez que tengamos un programa que resuelva un problema concreto, ser capaces de usarlo
Más detallesSISTEMAS DE COMUNICACIONES DE DATOS
SISTEMAS DE COMUNICACIONES DE DATOS Técnicas Digitales III Ing. Gustavo Nudelman 2012 Fundamentos de Networking Subtitulo o nombre del capitulo Capitulo 1 Universidad Tecnológica Nacional Definiciones
Más detallesSistemas distribuidos
Sistemas distribuidos El primer elemento clave en un sistema distribuido es la red. Definición Cualquier conjunto de dos o más equipos informáticos interconectados entre sí con el objetivo de compartir
Más detallesDESARROLLO DE FUNCIONES EN EL SISTEMA INFORMÁTICO EJEMPLO DE CUESTIONES BÁSICAS A CONOCER:
DESARROLLO DE FUNCIONES EN EL SISTEMA INFORMÁTICO EJEMPLO DE CUESTIONES BÁSICAS A CONOCER: 1) Para que sirve la función wait ( & dato ) y que valor se obtendría en la variable dato. 2) Diferencias entre
Más detallesIngeniería Informática. Curso 3º. Sistemas Operativos Examen Final. TEORIA. 4 de Septiembre de 2009
Ingeniería Informática. Curso 3º. Sistemas Operativos Examen Final. TEORIA. 4 de Septiembre de 2009 1. [PROCESOS] a) Considerar el siguiente código: void main() { int j=10; pid_t pid; for (int i=0; i
Más detallesIntroducción a C++ y Code::Blocks
Introducción a C++ y Práctica Imperativo Clase 1 Luis Agustín Nieto Departamento de Computación, FCEyN,Universidad de Buenos Aires. 28 de mayo de 2010 Menu de esta Tarde Funcional Vs. Imperativo (Intérprete
Más detalles