b'\n_START_ARTICLE_\nUser Datagram Protocol\n_START_SECTION_\nDescripci\xc3\xb3 t\xc3\xa8cnica\n_START_PARAGRAPH_\nUser Datagram Protocol (UDP) \xc3\xa9s un protocol m\xc3\xadnim de nivell de transport orientat a missatges documentat en el RFC 768 de la IETF._NEWLINE_En la fam\xc3\xadlia de protocols d\'Internet, UDP proporciona una senzilla interf\xc3\xadcie entre la capa de xarxa i la capa d\'aplicaci\xc3\xb3. UDP no atorga garanties per a l\'entrega dels seus missatges i l\'origen UDP no ret\xc3\xa9 estats dels missatges UDP que han estat enviats a la xarxa. UDP nom\xc3\xa9s afegeix multiplexat d\'aplicaci\xc3\xb3 i suma de verificaci\xc3\xb3 de la cap\xc3\xa7alera i la c\xc3\xa0rrega \xc3\xbatil. Qualsevol tipus de garanties per la transmissi\xc3\xb3 de la informaci\xc3\xb3 han de ser implementades en capes superiors.\n_START_SECTION_\nPorts\n_START_PARAGRAPH_\nUDP utilitza ports per permetre la comunicaci\xc3\xb3 entre aplicacions. El camp de port t\xc3\xa9 una longitud de 16 bits, de manera que el rang de valors v\xc3\xa0lids va de 0 a 65.535. El port 0 est\xc3\xa0 reservat, per\xc3\xb2 \xc3\xa9s un valor perm\xc3\xa8s com a port origen si el proc\xc3\xa9s emissor no espera rebre missatges com a resposta._NEWLINE_Els ports de l\'1 al 1023 s\'anomenen ports "ben coneguts" i en sistemes operatius tipus Unix enlla\xc3\xa7ar amb un d\'aquests ports requereix acc\xc3\xa9s com a root._NEWLINE_Els ports del 1024 al 49151 s\xc3\xb3n ports registrats._NEWLINE_Els ports del 49.152 al 65.535 s\xc3\xb3n ports ef\xc3\xadmers i s\xc3\xb3n utilitzats com a ports temporals, sobretot pels clients en comunicar-se amb els servidors.\n_START_SECTION_\nFiabilitat i solucions al control de congestions\n_START_PARAGRAPH_\nLes aplicacions UDP generalment han d\'acceptar p\xc3\xa8rdua, errors o duplicaci\xc3\xb3 de paquets. Algunes aplicacions com TFTP poden afegir mecanismes rudimentaris de fiabilitat a la capa d\'aplicaci\xc3\xb3 si cal. _NEWLINE_M\xc3\xa9s comunament, les aplicacions UDP no fan servir mecanismes de fiabilitat i fins i tot els hi poden fer nosa. Aplicacions de Streaming, jocs amb multi-jugadors en temps real i VoIP (veu sobre IP) s\xc3\xb3n exemples d\'aplicacions que sovint usen UDP. En aquestes aplicacions en particular la p\xc3\xa8rdua de paquets generalment no \xc3\xa9s un problema fatal. Si una aplicaci\xc3\xb3 requereix un alt grau de fiabilitat, un protocol com el TCP s\'hauria de fer servir en comptes de UDP._NEWLINE_Al contrari que TCP, les aplicacions basades en UDP no tenen necess\xc3\xa0riament bons mecanismes de control ni per evitar congestions de xarxa. Aplicacions UDP que consumeixen una gran part de l\'amplada de banda disponible podrien fer perillar l\'estabilitat de la \'Internet, ja que freq\xc3\xbcentment provoquen una c\xc3\xa0rrega que \xc3\xa9s inel\xc3\xa0stica. Mecanismes basats en xarxa han estat proposats per minimitzar els efectes potencials del col\xc2\xb7lapse per grans c\xc3\xa0rregues UDP incontrolades._NEWLINE_Elements de xarxa com encaminadors que fan servir encuament de paquets i t\xc3\xa8cniques per descartar s\xc3\xb3n sovint l\'\xc3\xbanica eina disponible per reduir el tr\xc3\xa0fic excessiu UDP.\n_START_SECTION_\nComparativa entre protocol UDP i TCP\n_START_PARAGRAPH_\nUDP: Proporciona un nivell de transport no fiable de datagrames, ja que afegeix poca informaci\xc3\xb3 necess\xc3\xa0ria per a la comunicaci\xc3\xb3 extrem a extrem del paquet que envia al nivell inferior. s\'utilitzen aplicacions com NFS (Network File System) i RCP (comandes per copiar fitxers entre ordinadors remots), per\xc3\xb2 sobretot s\'utilitza en tasques de control i en la transmissi\xc3\xb3 d\'\xc3\xa0udio i v\xc3\xaddeo a trav\xc3\xa9s d\'una xarxa. No introdueix retards per establir una connexi\xc3\xb3, no mant\xc3\xa9 l\'estat de connexi\xc3\xb3 algun i no realitza seguiment d\'aquests par\xc3\xa0metres. Aix\xc3\xad, un servidor dedicat a una aplicaci\xc3\xb3 particular pot suportar m\xc3\xa9s clients actius quan l\'aplicaci\xc3\xb3 corre sobre UDP en lloc de sobre TCP._NEWLINE_TCP: \xc3\x89s el protocol que proporciona un transport m\xc3\xa9s fiable de flux de bits entre aplicacions. Est\xc3\xa0 pensat per poder enviar grans quantitats d\'informaci\xc3\xb3 de manera fiable, alliberant el programador de la dificultat de gestionar la fiabilitat de la connexi\xc3\xb3 (retransmissions, p\xc3\xa8rdues de paquets, duplicaci\xc3\xb3 de paquets)que gestiona el mateix protocol. Per\xc3\xb2 la complexitat de la gesti\xc3\xb3 de la fiabilitat t\xc3\xa9 un cost en efici\xc3\xa8ncia, ja que per portar les gestions anteriors cal afegir gran quantitat d\'informaci\xc3\xb3 als paquets que envia. A causa del fet que els paquets per enviar tenen una mida m\xc3\xa0xima, com m\xc3\xa9s informaci\xc3\xb3 afegeix el protocol per la seva gesti\xc3\xb3, menys informaci\xc3\xb3 provindr\xc3\xa0 de l\'aplicaci\xc3\xb3. El segment TCP t\xc3\xa9 una sobrec\xc3\xa0rrega de 20 bytes en cada segment, mentre que UDP nom\xc3\xa9s hi afegeix 8 bytes. Per aix\xc3\xb2, quan \xc3\xa9s m\xc3\xa9s important la velocitat que la fiabilitat, s\'utilitza UDP. En canvi, TCP assegura la recepci\xc3\xb3 en dest\xc3\xad de la informaci\xc3\xb3 per transmetre.\n_START_SECTION_\nAplicacions\n_START_PARAGRAPH_\nMentre que la quantitat total de tr\xc3\xa0nsit UDP trobat en una xarxa t\xc3\xadpica sol ser de l\'ordre de nom\xc3\xa9s un petit percentatge, nombroses aplicacions clau d\'Internet utilitzen UDP, incloent-hi: el Domain Name System (DNS), on les consultes ha de ser r\xc3\xa0pides i nom\xc3\xa9s consisteix en una petici\xc3\xb3 \xc3\xbanica seguida d\'un paquet de resposta \xc3\xbanica, el Simple Network Management Protocol (SNMP), el Dynamic Host Configuration Protocol (DHCP) i el Routing Information Protocol (RIP)._NEWLINE_Tr\xc3\xa0nsit de veu i de v\xc3\xaddeo es transmeten generalment usant UDP. El v\xc3\xaddeo en temps real i els protocols de streaming d\'\xc3\xa0udio estan dissenyats per manejar ocasionals paquets perduts, en lloc de grans paquets de retards en cas de p\xc3\xa8rdua de paquets retransmesos. Com que tots dos TCP i UDP s\'executen en la mateixa xarxa, moltes empreses estan descobrint un recent augment en el tr\xc3\xa0fic UDP d\'aquestes aplicacions en temps real est\xc3\xa0 obstaculitzant el desenvolupament de les aplicacions que utilitzen TCP, com a punt de venda, comptabilitat i sistemes de base de dades._NEWLINE_Quan detecta la p\xc3\xa8rdua de paquets TCP, \xc3\xa9s portat cap enrere el seu "data rate usage". El desenvolupament de la qualitat per a les solucions del servei \xc3\xa9s crucial at\xc3\xa8s que les aplicacions de negoci s\xc3\xb3n importants per a les empreses.\n_START_SECTION_\nTransmissi\xc3\xb3 de v\xc3\xaddeo i veu\n_START_PARAGRAPH_\nUDP \xc3\xa9s generalment el protocol usat en la transmissi\xc3\xb3 de v\xc3\xaddeo i veu a trav\xc3\xa9s d\'una xarxa. Aix\xc3\xb2 \xc3\xa9s perqu\xc3\xa8 no hi ha temps per enviar de nou paquets perduts quan s\'est\xc3\xa0 escoltant alg\xc3\xba o veient un v\xc3\xaddeo en temps real (un petit sacrifici per tal de no repercutir en la sensaci\xc3\xb3 de \'temps real\' de cara a l\'usuari)._NEWLINE_Ja que tant TCP com UDP circulen per la mateixa xarxa, en molts casos passa que l\'augment del tr\xc3\xa0nsit UDP danya el correcte funcionament de les aplicacions TCP. Per defecte, TCP passa a un segon lloc per deixar les dades en temps real utilitzar la major part de l\'amplada de banda. El problema \xc3\xa9s que tots dos s\xc3\xb3n importants per a la major part de les aplicacions, de manera que trobar l\'equilibri entre ambd\xc3\xb3s \xc3\xa9s crucial (aqu\xc3\xad \xc3\xa9s on es veu l\'efici\xc3\xa8ncia d\'un programa o aplicaci\xc3\xb3).\n_START_SECTION_\nCodi d\'exemple (Python 3.x)\n_START_PARAGRAPH_\nEl seg\xc3\xbcent codi d\'exemple mostra com utilitzar el protocol UDP per una comunicaci\xc3\xb3 client/servidor:_NEWLINE_Servidor:_NEWLINE_import socketserverprint("Servidor iniciant...")class MyUDPHandler(socketserver.BaseRequestHandler):_NEWLINE_ def handle(self):_NEWLINE_ data = self.request[0].strip()_NEWLINE_ socket = self.request[1]_NEWLINE_ print("%s Ha escrit:" % self.client_address[0])_NEWLINE_ print(data)_NEWLINE_ socket.sendto(data.upper(), self.client_address)if __name__ == "__main__":_NEWLINE_ HOST, PORT = "localhost", 9999_NEWLINE_ server = socketserver.UDPServer((HOST, PORT), MyUDPHandler)_NEWLINE_ server.serve_forever()_NEWLINE_Client (Canvia "localhost" per l\'adre\xc3\xa7a IP del servidor):_NEWLINE_import socketimport sysprint("Client iniciant...")HOST, PORT = "localhost", 9999data = " ".join(sys.argv[1:])sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)sock.sendto(bytes(data + "\\n","utf8"), (HOST, PORT))received = sock.recv(1024)print("Enviat: %s" % data)print("Rebut: %s" % received)\n_START_SECTION_\nCodi d\'exemple (C++)\n_START_PARAGRAPH_\nEl seg\xc3\xbcent codi mostra com es pot utilitzar el protocol UDP per una comunicaci\xc3\xb3 client/servidor:_NEWLINE_Servidor:_NEWLINE_#include <winsock.h>#pragma comment(lib,"ws2_32.lib")const int BufLen = 1024;int main(){_NEWLINE_ WSADATA wsaData;_NEWLINE_ SOCKET RecvSocket;_NEWLINE_ sockaddr_in RecvAddr;_NEWLINE_ int Puerto = 2345;_NEWLINE_ char RecvBuf[BufLen];_NEWLINE_ sockaddr_in SenderAddr;_NEWLINE_ int SenderAddrSize = sizeof(SenderAddr);_NEWLINE_ WSAStartup(MAKEWORD(2,2), &wsaData);_NEWLINE_ RecvSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);_NEWLINE_ RecvAddr.sin_family = AF_INET;_NEWLINE_ RecvAddr.sin_port = htons(Puerto);_NEWLINE_ RecvAddr.sin_addr.s_addr = INADDR_ANY;_NEWLINE_ bind(RecvSocket, (SOCKADDR *) &RecvAddr, sizeof(RecvAddr));_NEWLINE_ recvfrom(RecvSocket,RecvBuf, BufLen,0,(SOCKADDR *)&SenderAddr,&SenderAddrSize);_NEWLINE_printf("%s\\n",RecvBuf);_NEWLINE_ closesocket(RecvSocket);_NEWLINE_ WSACleanup();}_NEWLINE_Client (Canvia "127.0.0.1" per l\'adre\xc3\xa7a IP del servidor):_NEWLINE_#include <winsock.h>#pragma comment(lib,"ws2_32.lib")int main(){_NEWLINE_WSADATA wsaData;_NEWLINE_ SOCKET SendSocket;_NEWLINE_ sockaddr_in RecvAddr;_NEWLINE_int Puerto = 2345;_NEWLINE_ char ip[] = "127.0.0.1";_NEWLINE_ char SendBuf[] = "Hola!!!!";_NEWLINE_ WSAStartup(MAKEWORD(2,2), &wsaData);_NEWLINE_ SendSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);_NEWLINE_ RecvAddr.sin_family = AF_INET;_NEWLINE_ RecvAddr.sin_port = htons(Puerto);_NEWLINE_ RecvAddr.sin_addr.s_addr = inet_addr(ip);_NEWLINE_ sendto(SendSocket,SendBuf,strlen(SendBuf)+1,0,(SOCKADDR *) &RecvAddr,sizeof(RecvAddr));_NEWLINE_ WSACleanup();}'