C / multiple servers

Hint: Click ↑ Pushed to see the most recently updated apps and libraries or click Growing to repos being actively starred .
0
sitas 🍂
9 (+0)

Operate multiple servers interactively in parallel ssh

0 comments    
0
6 (+0)

Stress tester for RTMP media servers,this tool is based on librtmp,It uses multithreading for multiple concurrent connections。

0 comments    
0
dhtest 🌿
194 (+0)

A DHCP client simulation on linux. It can simulates multiple DHCP clients behind a network device. It can help in testing the DHCP servers or in testing switch/router by loading the device with multiple DHCP clients.

0 comments    
0
netdata 🌿
55602 (+15)

Real-time performance monitoring, done right! https://www.netdata.cloud

0
libredis 🍂
64 (+0)

A C based general low-level PHP extension and client library for Redis, focusing on performance, generality and efficient parallel communication with multiple Redis servers. As a bonus, a Ketama Consistent Hashing implementation is provided as well.

0
mhttp 🍂
6 (+0)

Multi-source Multipath HTTP (mHTTP) enables users to establish simultaneous connections with multiple servers to fetch a single content. mHTTP is designed to combine the advantage obtained from distributed network infrastructures provided by CDNs with the advantage of multiple interfaces at end-users. Unlike existing proposals: a) mHTTP is a purely receiver-oriented mechanism that requires no modification either at the server or at the network, b) the modifications are restricted to the socket interface; hence, no changes are needed to the applications or to the kernel, and c) it takes advantage of multiple types of path diversity in the Internet.

0 comments    
0
4 (+0)

This project implements a parallel file server and synchronization related problems. Clients (CLs) and file servers (FSs) know the (IP,PORT) of meta-data manager (MM). Therefore file servers export their (IP,PORT) to MM, and MM imports them to any connected CL. We put predefined MM’s (IP,PORT) in config.h files of all projects (PFS_client, PFS_MM, and PFS_server). Our codes don’t have any warnings and all warnings are related to test codes! We added one function at the beginning of the test codes called “initialize(argc, argv);”! It’s necessary to initialize the client to make sockets with MM & FSs. For modularity it was better to separate initialization step from pfs_create (not inside this function), because it may call pfs_create multiple times. All ‘w’ in test codes should be changed to “w”! Also I put “argc=2;argv[1]=”1”;” at the beginning just for debugging the code that could be omitted and compile again. Also it is assumed that the test-c1.c is first executed and then test-c2.c, test-c3.c, test2.c and test3.c can be run, because test-c1.c creates the pfs_file1 that can be used by other test codes. Also “file” string inside all test codes was changed to “pfs_file1” to be compatible with the first test code (test-c1.c).

0 comments    
0
i.Q 🌿
4 (+0)

IN TRUTH preferring A "FIRST FOCUS ON A "FUTURE PROOF" "SEMPER GUMBI" "ALWAYS FLEXIBLE" DYNAMIC W3C ECMA IEEE ORG ASM IP TCP HTTPS SSL TSL OPENSSL C C++ DLL EXE SRC CODE FLASH BIOS CLONEZILLA PENDRIVELINUX BYOos DIYos PORTABLE OS FREE OPEN SECURITY CONSCIOUS PRIVACY INSTISTENT POLICING THE POLICE MENTALITY TRUST NO ONE BUT G_D META TAG SQL DRIVER IEEE OPENRESTY eNGINeX NGINX LUA LOVE2D SOLAR2D JAVASCRIPT HTML CSS PNG FLAC COMMON GUI MVC +++ PATTERNS REAL CHILDREN REAL GRANDMOTHERS REAL WOMEN AWARE EXTENSIBLE STANDARD CHIP INSTRUCTION SET, BIG NUMBER SET USING ALL THE UNIQUE HASHES AND B64 URL ENCODED VALUES OF ALL THE CORRESPONDING LOSSLESS PNG IMAGES AND FLAC AUDIO SOUNDS KNOWN TO 'US' 'ALL' ANYWHERE WORLDWIDE, AND A HTML-IMAGE-MAP-BASE-CONTROL-ELEMENT-LIKE "THINKING" "APPROACH" SQL DATA BOUND TO DEFINED DYNAMIC LUA CALLABLE FUNCTIONS TO EMBEDDED ASSEMBLY ROUTINES OR DIRECT HARDWARE SWITCHES TO SAY GO RUN THIS FUNCTION AFTER THIS "EVENT" OCCURED AT THIS X,Y PIXEL POSITION ON ANY SCREEN'S COORDINATE SYSTEM USING IMAGE-MAP COMPLEX X1,Y1 to X2,Y2 to X3,Y3 POINT PATH POLYGONAL AREAS ATTACHED TO "EVENTS" STANDARDIZED AND SQL ASSOCIATED WTIH A MASSIVE INCREDIBLE BEAUTIFUL COMMON SHARED INTEREST REUSABLE NON-PROPRIETARY GUI TRANSPARENT IMMEDIATE MODE GUI PNG LOSSLESS IMAGES OF EVERY CONCEIVABLE TYPE OF GRAPHICAL USER INTERFACE CONTROL AUDIO SOUND AND GRAPHICAL IMAGE FROM A SPACE COCKPIT TO AN AUTOMOBILE TO A MOTOR CYCLE TO A TOASTER OVEN TO A MOBILE PHONE AND DESKTOP TO A DRIVE IN THEATRE SCREEN A COMMON SET OF HUGE BUT RESIZEABLE TO SMALL PNG BEAUTIFUL PRE-STYLED SAVED PHOTOGRAPHIC IMAGES ALL MORGUEFILE.COM MORGUEFILE LICENSED TO ALL FOR FREE WITH "ATTRIBUTION CREDIT AS IS TRUTH AS IS GOOD AND HONORABLE" WITH AN OPEN IMAGE AND SOUND FILE LICENSE FOR RESOURCES JUST LIKE ALL CODE SHOULD BE UNDER A SIMPLE NO BS LEGAL MUMBO JUMBO FILTH JUST KNOWN AND STANDARD MIT LICENSE OPEN SOURCE NO-GPL-RESTRICTIONS PUBLIC DOMAIN DEDICATION for all poor children too everywhere INDUSTRY AGREED UPON MANUFACTURER "AND" HARDWARE "ENGINEER" AGREED UPON STANDARD CHIP INSTRUCTION SET, COMMON HUGE RASTER SET OF TRANSPARENT "STYLED" GUI IMAGE SET THAT HAVE ALL "EVENTS" EASILY ATTACHABLE USING KNOW HTML JS CSS STYLE ATTRIBUTE EVENT W3C MODELS AS WELL AS WxWidgets ETC BUT USING IMAGES THAT CAN BE SCALED DOWN FROM A THEATRE SIZED .PNG IMAGE FOR "REAL WORLD" "DRIVE IN MOVIE VIEWING SIZED SCREENS" DOWN TO A SMALL PHONE SCREEN KEEPING ABSOLUTE LOSSLESS GRAPHICAL RESOLUTION IN TACT THUS A HUGE COMMON SHARED REPOSITORY OF ALL KINDS OF "CHECKBOX" "RADIO BUTTONS" "BUTTONS" "CALENDARS" "TEXTBOXES" "DATAGRIDS" COULD BE CONSTRUCTED BY REDRAWING PNG IMAGES AND ATTACHING THE CORRESPONDING STYLES ATTRIBUTES AND EVENT BINDINGS AS NECESSARY AT THE GEM OS GUI LUA IMMEDIATE GOOEY G.U.I. "GSPOT" THINKING LEVEL BUT INSTEAD OF USING LUA USING ACTUAL BOOLEAN LOGIC CIRCUIT DESIGNED IN LOGIC REPEATING THE SAME DATABASE LOOKUPS JUST FAST AS LIGHTENING beCAUSE 'we' CAN DO TOGETHER more than any 1 can ever do alone UNITED WE ARE STRONG divided we are weak LOVE YOU I DO Oh how I LOVE 'you' AND HUGE DATA SCIENCE NUMBER BASE NOT JUST SILLY "DOUBLE" "LONG" OR "REAL" OR "DECIMAL" BUT REAL REALLY REAL G_D CONSIDERING SOMEWHAT LARGE WORTHY OF A NUMBER AND NUMBER BASE THINKING intellectual TIME TO RE-THINK SOME THINGS AT THE BASE level using A HUGE UNCOUNTABLE ALWAYS INCREASING NUMBER OF UNIQUE IMAGES WORLDIWIDE EVERYWHERE EVEN THE SLIGHTEST PIXEL CHANGE IN ANY IMAGE ANYWHERE IS A NEW "HASH" UNIQUE VALUE MATHEMATICALLY SPEAKING SO THINK BIG REALLY BIG BIGGER THAN THAT AND CONSTRUCT A HUGE KEY/VALUE EMBEDDEDABLE ONBOARD AN SSD CHIP "DATABASE" LOOKUP TABLE OF ALL KNOWN REAL WORLD UNIQUE IMAGE HASHES AND BASE 64 URL ENCODED VALUES MAPPED AS KEY/VALUES IN EMBEDDED FAST NON-VOLATILE STORAGE SSD +++ FAST SSD STORAGE CHIPS NTIER HARDWARE LEVEL EXPERTISE SPEED PERFORMANCE MEASURING using MULTIPLE OS "LOOPS" fast immediate RTOS REAL TIME LOOKUPS TO HUGE MULTITERABYTE SSD "THICK" CHIPS EASILY DOABLE FOR THOSE I THE KNOW WITH A MIND TO DO SO AND WORK TOGETHER TO MAKE GOOD INCREDIBLY BETTER AND TO COMPRISE A SINGLE SYSTEM OF MULTIPLE Operating Systems COMMUNICATING FASTER THAN FAST VIA HARDWARE AWARE OF THEIR "REAL NEEDS" AT THE KERNEL HARDWARE LAYER OF ABSTRACTION TO MAKE IT A GOOD SOFTWARE K.I.S.S. USING STANDARD SQL-BASED ONE AGREED UPON "STANDARD" MULTILANGUAGE C-BASED COMPILER ARCHITECTURE FOR ALL KNOWN CHIPSETS TO BE SUPPORTED meaning X64 + X86 + ARM ASSEMBLER, CHIP INSTRUCTION SET, MAX CHIP INTERNAL SETTINGS, AND FOCUS FIRST to develop worldwide with all the 'blessed' ones' incredible PUREHEART IN TRUTH 'minds' 'souls' MOST IMPORTANT TO REALIZE HOW SPECIAL EACH 'soul' is having an 'easter' 'egg' 'blessing' hidden in each soul making it VERY IMPORTANT to look after the least among 'us' for 'you' know not where the 'EASTER EGG' is hidden in who's 'soul' as our CREATOR the MASTER PROGRAMMER of us 'all' our very 'soul' a 'piece of code' to OUR CREATOR hid EASTER EGG blessings in every soul for each to search and find their WAY in LIFE with G_D so it is UP TO 'US" ALL TO NURTURE EACH CHILD TO GIVE THEIR "SEED" THEIR "BLESSING" FERTILE, SAFE, HEALTHY "FIRM" "FEELING" "WARM" "NUTRITIOUS" "LEARNED" "OPPORTUNISTIC" "SUPPORTIVE" "FERTILE" "POSITIVE" ROOM TO GROW INTO A "BEAUTIFUL 'FRUIT-FILLED' TREE OF LIFE" my LOVE MAKE A WAY STRONGER FASTER MORE EFFICIENT, SUCCINCT, TIME-TESTED, BATTLE-HARDENED, PROVEN S.O.P. STANDARD OPERATING PROCEDURE FOR CHIP DESIGNING AND GUI RE-USE VIA EMBEDDED SSD MASS NON-VOLATILE STORAGE FOCUSING FIRST AND FOREMOST ON A STANDARD FOR ALL CHIPS IEEE-SUPPORTED "FINALLY" "INTERNATIONAL FOR REAL GOING WAY Way way BACK" BACK TO BASICS ASCII-ENCODING-OF-MASS-DATA-HASH-UNIQUE-ID-BASE64URLVALUE JAVASCRIPT/HTML COMMON CSS STYLE PNG TRANSPARENCY XCF GIMP LAYERED IMAGE AWARE MORE HUMAN LESS ARTIFICIAL FULL INTERNATIONAL LANGUAGE TRANSLATOR ON-BOARD EVERYTHING +++ NTIER LAYERS OF MULTIPLE OS EMBEDDED AMULETtechnologies.com GEM OS - like DYNAMICALLY REMOTELY RE-FLASHABLE STANDARD INSTRUCTION SET SDK API TCP/IP HTTP(S) OPEN SSL +++ QUANTUM CIPHER READY ONBOARD CHIP INSTRUCTION SET MAX NUMBER OF CPU REGISTRERS MAX SIZE OF CPU REGISTERS +++ MAX NUMBER OF DDR SLOTS MAX NUMBER OF PCI "OLD SCHOOL TURTLE BEACH BACK IN THE DAY' SOUND CARD SLOTS MAX HDMI SLOTS MAX RAM ETC SET MAX LIMITS GO FROM THERE ALLOWING BLANK INSTRUCTION REFERENCES FOR FUTURE EXENSIONS AND USE SQL PLEASE TO SEPARATE AND EMBED FIRST ALL THE KNOWN UNIQUE BINARY IMAGES LIKE .PNG IMAGES RASTERIZED ALL THE UNIQUE IMAGES NOT JUST THE UNIQUE UNICODE CHARACTER SET WHICH TELLS ONLY BUT A FRACTION OF THE "WHOLE HUMAN EXISTENCE STORY" IN "IDEA" "A PICTURES SAYS A THOUSAND WORDS" VERY HUGE NUMBER BASE THEN WE CAN KEEP TALKING BUT DO THAT STANDARD OPERATING PROCEDURE HUGE IMAGE UNIQUE ID SET AND ALL INSTRUCTIONS STANDARDIZED WITH MAX "EVERYTHING YOU NEED ELECTRICAL CIRCUIT CHIP DESIGN" beLOVEd 'bleesed' 'gift'ed one I LOVE FOCUS FIRST ON A STANDARD INSTRUCTION SET FOR ALL CHIPS TO STANDARDIZE UPON WITH AN ABSOLUTELY HUGE NUMBER BASE FOCUS" AND "AMULET" "ON CHIP GEM OS" 'thinking' using "COMMON IMMEDIATE GUI" "PNG" "MODS-styles" "EVENTS" WITH GOOD UNDERSTANDABLE K.I.S.S. "DYNAMIC" SQL-BASED "FUNCTION CALL SEQUENCE" "STACK" ENVIRONMENT USING RE-INTERPRETING RE-COMPILING RE-FLASHING DYNAMIC function call stack sequences returned by "STANDARD" S.Q.L. QUERIES, interpreter/compiler/assembler executable path, function,code +'version' data fields over .dll's and recompiling using A SQLite https://en.wikipedia.org/wiki/Data_Transfer_Object D.T.O. Data Transfer Object 'paradigm'. MORE DYNAMIC MODERN POWERFUL SQL CREATE DROP INSERT UPDATE DELETE TRUNCATE SELECT Database Command SQLite APPROACH over a XML, JSON, etc. plain text 'file formats' FILE BASED APPROACH as both a document container meaning the entire html file with her .flac lossless audio files, her .png transparent lossless image files, her css class style files, js, sql.js and other libraries of javascript function files along with any other files all wrapped up in a single database file that standard code can easily extract and make the 'onload' event much more modern, succinct, standard, understandable, extensible, maintainable, accessible and better than today, even just using SQLite as intended for 'data' to be inserted into the above mentioned js and css and html as values SELECTed from a database, or as a network transport where the function 'args' input arrays become a single .SQLITE3.db file containing all the input even huge multi-gigabyte arrays of audio and images and texts all in one single function call containing but a path/url to a large .SQLITE3 file, or a client (think SQL.js by the AMAZING EMSCRIPTEM serious 'hero' Alon Zakai kripken https://github.com/emscripten-core/emscripten or server-side state management system, and generally SQLite3 tables are as we all know the ultimate backend and hence base for all wrappers for any objects, libraries, code, etc. like a .LOVE file just an incredible .zip file with added functionality type of 'thinking' so consider this a 'seed' from which you 'blessed' 'kind' beLOVEd one in TRUTH with most PUREHEART will grow a new 'tree' of LIFE for future generations to establish a COMMON-GUI-REPOSITORY to standardize element-attribute-style-event-function-sql-tcp-ip-udp-http(s)+++ between all languages and implementing real-world code incorporating multiple Multi-Platform-Desktop-Web-Browser-JS-and-LUA-org-to- 'in the end' ON-BOARD-EMBEDDED-SQLITE3-ON-CHIP-sacred-FASTER-than-fast- 're-flashing or updating its own embedded SQLite database containing ALL THE ACTUAL DYNAMICALLY CALLABLE AND LOADABLE LUA (etc) FUNCTIONS AND LIBRARIES as WELL AS ALL THE .PNG and .FLAC, IMAGE AND AUDIO FILES, TO BE USED AS Graphical User Interface "RESOURCES" to make for some 'real' GOOD DISRUPTive-INNOVATION for our most worthy, young, future generations of most PUREHEART in TRUTH highly intelleQtual, creative, cool, inventive GOOD Q.I.D.s LIFTED UP by GOOD K.I.D.s with most PUREHEART so they have something just like AMULETtechnolgies-com G.E.M. OS SEPARATION OF THE GRAPHICAL "DRAWING" INTO ITS OWN FASTER THAN ANY OS "LOOP" CLOSER TO THE MACHINE TO THE HARDWARE coded by those 'we all know are so very intelligent and 'kind' kind of DEVELOPERS of CUSTOM GUI CONTROLs for any device, language, operating system, video card, sound card so our 'children in the future' have a faster than fast MACHINE-OS-APP-BROWSER-to-GEM-to-Video-to-Sound-Cards-SYSTEM-level-FUNCTION-LIBRARY 'standard, powerful, full system-level access' amd STANDARD POWERFUL FULL SYSTEM AT THE HARDWARE AND SOFTWARE LEVEL SERIOUS HARDCORE DEEP THOUGHTFUL AND MUST BECOME SECOND NATURE WIDELY UNDERSTOOD KNOWLEDGE TO HELP ALL LEARN AND REUSE YOUR THOUGHTFUL KNOWLEDGE most KIND GOOD beLOVED 'blessed' 'maintainers' of STANDARD, POWERFUL, SYSTEM-LEVEL ACCESSIBLE FOR ALL AND RESPONSIBLY AND TIMELY MAINTAINED SUPPORTED HTML WEB Graphical User Interface GUI PARADIGM MODEL WAY using OPEN SOUCE C, LUA and much thanks to the GNU C GCC, LUA AND SQLITE OPEN SOURCE COMMUNITIES that will run on all desktops including LINUX pathX /i.Q/ MAC pathX and WINDOWS pathW c:\i.Q\ and the same JS GUI can be used to make http(s) network calls to remote web servers' SYSTEM FUNCTION LIBRARIES that thanks to AMULET GEMstudio PRO can re-use HARDWARE FASTER THAN FAST ON-CHIP ON-BOARD REAL DIRECT VIDEO CARD SOUND CARD TO HARDWARE EMBEDDED SQLITE DATABASE INTERACTING WITH HARDWARE RE-FLASHABLE UPDATEABLE LUA OR C K.I.S.S.y k.i.s.s.y LOVEy DOVEy MOST PLAYFUL YET MOST POWERFUL the same HTML CSS JAVASCRIPT web GUI as the VERY GOOD MOST EASILY STANDARDIZABLE VIA AN http://AMULETtechnologies.com HARDWARE DEVELOPER AMULET GUI CONTROL DEVELOPER API REGISTRATION FOR INFRAGISTICS AND TELERIK etc GUI CONTROL DEVELOPERS and an http://AMULETtechnologies.com SOFTWARE DEVELOPER REGISTRATION PROCESS FOR ALL SOFTWARE DEVELOPERS AND WEB DEVELOPERS TO BE ABLE TO ACCESS NATIVE SYSTEM CALLS SECURELY beCAUSE "AMULETtechnologies.com OBJECTIVELY has already 'verified' each of the 'developers' so they know who is who in the zoo so to speak" and all of 'us' more and less technical most PUREHEART in TRUTH here with 'us' all, YOUNG and OLD alike, can enjoy a web, desktop or mobile app VIRTUAL FRIENDLY NEIGHBORHOOD 3D "LOOK" and "FEEL" DRIVE THROUGH with the real you and me ... G_D IS WITH US ... GOOD IS COMING ... PROMISE ... TURN IT UPSIDE DOWN ... Isaiah ... Matthew 18:3 ... Blessed are the PUREHEART for they shall see G_D. Matthew 5:8 ... "Your 'gift' little drummer boy given out of the simple desperation of a PURE LOVE is the one favored above all." ... Little Drummer Boy - The 'Gift' of LOVE 1968 ... THE POWER OF YOUR INTENTIONS ... TRUTHstreamMedia ... TINNA TINH "REMOVE NEGATIVE ENERGY" ... DRUKMO GYAL "GREEN TARA" ... NO DIGGITY. NO DAP. ... GIRLS GENERATION "GEE" ... GIRLS GENERATION "WE BRING THE BOYS OUT" ... NELLY "BATTER UP" ... MURPHY LEE "WHAT DA' HOOK GON' BE?" ... PUREHEART ... KEEP YOUR PUREHEART ... THAT'S THE HOOK ... YOU ARE GOING TO NEED IT ... PROMISE ... Did I mention my name is on the wall at Naval Justice School, Newport, Rhode Island, ameriQa? ... See you back 'home' ... PROMISE ... I AM N.A.F.F. Not A FuQQinQ Fan of 'app stores' 'controlling' what 'apps' are 'okay' and what 'apps' are not 'okay' so jQke'em if they can't taQe a fuQQ ... cQunt me Qut ... pass ... I'll pass ... web is fine ... desktop is fine ... no need to install using your 'app store' FILTHY 'filter' of the 'CHILDren' of 'darkness' ... RIGHT Arch Bishop Vigano 'CHILDREN OF DARKNESS' ... FILTHY! MONSTER! ... pass ... please wegro ... I'll take a pass ... pass I AM OUT ... takinQ a pass ... FREE, OPEN, TRUTH, PUREHEART 'apps' 'opinions' ONLY no 1/2 TRUTH 1/2 HEART fake TRUTHtians wel.com ... AMULET directly to LUA to C or AMULET to JavaScript to LUA to C as GUI FrontEnd; LUA C +++ as Logic MiddleWare; SQLite as Data BackEnd. You know what I AM getting at, RIGHT? MATTHEW 18:6 ... JOHN 15:1-22 ... MATTHEW 15:9 ... MATTHEW 18:3 ... EZEKIEL 3:17 ... MATTHEW 5:8 ... cool. WORD. Love ya' bye. ENTERTAIN NO DOUBT. We are many. We are GOOD. We are coming. GOOD IS COMING and G_D IS WITH US. PROMISE. MATTHEW 5:8. PUREHEART. MATTHEW 18:3. Do you believe in coincidences? My grandfather's father, my great-grandfather, John Edgar Flaherty, was born 1883 December 25 and his mother was named Mary and his father's name was Joseph ... My first son, John Edgar Flaherty V, was born on my grandfather, John Edgar Flaherty Jr's birthday, July 13. My grandfather, John Edgar Flaherty Jr, served in the U.S. Army 'reluctantly' and was sent as a 'medic' driving Harley Davidson sidecar motorcycles to protect the PUREHEART PILIPINAs in Leyte, Philippines. On November 10, 2020, I celebrated my 30th anniversary with a GOOD HEARTED WOMAN sing it Waylon from the Philippines and her mother lived in Leyte, Philippines WAY back then when I was just a 'twinkle' in G_D's eyes, my mom's eyes and my dad's eyes. ... The more I learn the more I realize how little I know. ... Bigger than you can imagine. ... PUREHEART ... PURE CRYSTALLINE LAUGHTER ... LOVE ONE ANOTHER ... I AM so very proud of the community of software engineers, developers, and other titles 'they' call 'us' beCAUSE you are in TRUTH with most PUREHEART most generous and exactly the kind of GO-GETTERS I AM looking for my new GET US BACK TO HEAVEN project ... slowest runner in the front of the line ... double time ... WE ALL FINISH ... NO ONE LEFT BEHIND ... EVERYONE FINISHES THE 'RUN" ... "FEEL ME" ... "I SEE YOU" ... THANK YOU ALL ... MOST HUMBLE AND GREAT ... you are the "kind" kind I like ... For the record, I, John Edgar Flaherty IV, was born 1968 August 12. JOHN 15:1-22. Respectfully, John Edgar Flaherty IV "MAKE A WAY"

0 comments    
0
8 (+0)

Overview For this assignment you will be developing and implementing : An On-Demand shortest-hop Routing (ODR) protocol for networks of fixed but arbitrary and unknown connectivity, using PF_PACKET sockets. The implementation is based on (a simplified version of) the AODV algorithm. Time client and server applications that send requests and replies to each other across the network using ODR. An API you will implement using Unix domain datagram sockets enables applications to communicate with the ODR mechanism running locally at their nodes. I shall be discussing the assignment in class on Wednesday, October 29, and Monday, November 3. The following should prove useful reference material for the assignment : Sections 15.1, 15.2, 15.4 & 15.6, Chapter 15, on Unix domain datagram sockets. PF_PACKET(7) from the Linux manual pages. You might find these notes made by a past CSE 533 student useful. Also, the following link http://www.pdbuchan.com/rawsock/rawsock.html contains useful code samples that use PF_PACKET sockets (as well as other code samples that use raw IP sockets which you do not need for this assignment, though you will be using these types of sockets for Assignment 4). Charles E. Perkins & Elizabeth M. Royer. “Ad-hoc On-Demand Distance Vector Routing.” Proceedings of the 2nd IEEE Workshop on Mobile Computing Systems and Applications, New Orleans, Louisiana, February 1999, pp. 90 - 100. The VMware environment minix.cs.stonybrook.edu is a Linux box running VMware. A cluster of ten Linux virtual machines, called vm1 through vm10, on which you can gain access as root and run your code have been created on minix. See VMware Environment Hosts for further details. VMware instructions takes you to a page that explains how to use the system. The ten virtual machines have been configured into a small virtual intranet of Ethernet LANs whose topology is (in principle) unknown to you. There is a course account cse533 on node minix, with home directory /users/cse533. In there, you will find a subdirectory Stevens/unpv13e , exactly as you are used to having on the cs system. You should develop your source code and makefiles for handing in accordingly. You will be handing in your source code on the minix node. Note that you do not need to link against the socket library (-lsocket) in Linux. The same is true for -lnsl and -lresolv. For example, take a look at how the LIBS variable is defined for Solaris, in /home/courses/cse533/Stevens/unpv13e_solaris2.10/Make.defines (on compserv1, say) : LIBS = ../libunp.a -lresolv -lsocket -lnsl -lpthread But if you take a look at Make.defines on minix (/users/cse533/Stevens/unpv13e/Make.defines) you will find only: LIBS = ../libunp.a -lpthread The nodes vm1 , . . . . . , vm10 are all multihomed : each has two (or more) interfaces. The interface ‘eth0 ’ should be completely ignored and is not to be used for this assignment (because it shows all ten nodes as if belonging to the same single Ethernet 192.168.1.0/24, rather than to an intranet composed of several Ethernets). Note that vm1 , . . . . . , vm10 are virtual machines, not real ones. One implication of this is that you will not be able to find out what their (virtual) IP addresses are by using nslookup and such. To find out these IP addresses, you need to look at the file /etc/hosts on minix. More to the point, invoking gethostbyname for a given vm will return to you only the (primary) IP address associated with the interface eth0 of that vm (which is the interface you will not be using). It will not return to you any other IP address for the node. Similarly, gethostbyaddr will return the vm node name only if you give it the (primary) IP address associated with the interface eth0 for the node. It will return nothing if you give it any other IP address for the node, even though the address is perfectly valid. Because of this, and because it will ease your task to be able to use gethostbyname and gethostbyaddr in a straightforward way, we shall adopt the (primary) IP addresses associated with interfaces eth0 as the ‘canonical’ IP addresses for the nodes (more on this below). Time client and server A time server runs on each of the ten vm machines. The client code should also be available on each vm so that it can be evoked at any of them. Normally, time clients/servers exchange request/reply messages using the TCP/UDP socket API that, effectively, enables them to receive service (indirectly, via the transport layer) from the local IP mechanism running at their nodes. You are to implement an API using Unix domain sockets to access the local ODR service directly (somewhat similar, in effect, to the way that raw sockets permit an application to access IP directly). Use Unix domain SOCK_DGRAM, rather than SOCK_STREAM, sockets (see Figures 15.5 & 15.6, pp. 418 - 419). API You need to implement a msg_send function that will be called by clients/servers to send requests/replies. The parameters of the function consist of : int giving the socket descriptor for write char* giving the ‘canonical’ IP address for the destination node, in presentation format int giving the destination ‘port’ number char* giving message to be sent int flag if set, force a route rediscovery to the destination node even if a non-‘stale’ route already exists (see below) msg_send will format these parameters into a single char sequence which is written to the Unix domain socket that a client/server process creates. The sequence will be read by the local ODR from a Unix domain socket that the ODR process creates for itself. Recall that the ‘canonical’ IP address for a vm node is the (primary) IP address associated with the eth0 interface for the node. It is what will be returned to you by a call to gethostbyname. Similarly, we need a msg_recv function which will do a (blocking) read on the application domain socket and return with : int giving socket descriptor for read char* giving message received char* giving ‘canonical’ IP address for the source node of message, in presentation format int* giving source ‘port’ number This information is written as a single char sequence by the ODR process to the domain socket that it creates for itself. It is read by msg_recv from the domain socket the client/server process creates, decomposed into the three components above, and returned to the caller of msg_recv. Also see the section below entitled ODR and the API. Client When a client is evoked at a node, it creates a domain datagram socket. The client should bind its socket to a ‘temporary’ (i.e., not ‘well-known’) sun_path name obtained from a call to tmpnam() (cf. line 10, Figure 15.6, p. 419) so that multiple clients may run at the same node. Note that tmpnam() is actually highly deprecated. You should use the mkstemp() function instead - look up the online man pages on minix (‘man mkstemp’) for details. As you run client code again and again during the development stage, the temporary files created by the calls to tmpnam / mkstemp start to proliferate since these files are not automatically removed when the client code terminates. You need to explicitly remove the file created by the client evocation by issuing a call to unlink() or to remove() in your client code just before the client code exits. See the online man pages on minix (‘man unlink’, ‘man remove’) for details. The client then enters an infinite loop repeating the steps below. The client prompts the user to choose one of vm1 , . . . . . , vm10 as a server node. Client msg_sends a 1 or 2 byte message to server and prints out on stdout the message client at node vm i1 sending request to server at vm i2 (In general, throughout this assignment, “trace” messages such as the one above should give the vm names and not IP addresses of the nodes.) Client then blocks in msg_recv awaiting response. This attempt to read from the domain socket should be backed up by a timeout in case no response ever comes. I leave it up to you whether you ‘wrap’ the call to msg_recv in a timeout, or you implement the timeout inside msg_recv itself. When the client receives a response it prints out on stdout the message client at node vm i1 : received from vm i2 <timestamp> If, on the other hand, the client times out, it should print out the message client at node vm i1 : timeout on response from vm i2 The client then retransmits the message out, setting the flag parameter in msg_send to force a route rediscovery, and prints out an appropriate message on stdout. This is done only once, when a timeout for a given message to the server occurs for the first time. Client repeats steps 1. - 3. Server The server creates a domain datagram socket. The server socket is assumed to have a (node-local) ‘well-known’ sun_path name which it binds to. This ‘well-known’ sun_path name is designated by a (network-wide) ‘well-known’ ‘port’ value. The time client uses this ‘port’ value to communicate with the server. The server enters an infinite sequence of calls to msg_recv followed by msg_send, awaiting client requests and responding to them. When it responds to a client request, it prints out on stdout the message server at node vm i1 responding to request from vm i2 ODR The ODR process runs on each of the ten vm machines. It is evoked with a single command line argument which gives a “staleness” time parameter, in seconds. It uses get_hw_addrs (available to you on minix in ~cse533/Asgn3_code) to obtain the index, and associated (unicast) IP and Ethernet addresses for each of the node’s interfaces, except for the eth0 and lo (loopback) interfaces, which should be ignored. In the subdirectory ~cse533/Asgn3_code (/users/cse533/Asgn3_code) on minix I am providing you with two functions, get_hw_addrs and prhwaddrs. These are analogous to the get_ifi_info_plus and prifinfo_plus of Assignment 2. Like get_ifi_info_plus, get_hw_addrs uses ioctl. get_hw_addrs gets the (primary) IP address, alias IP addresses (if any), HW address, and interface name and index value for each of the node's interfaces (including the loopback interface lo). prhwaddrs prints that information out. You should modify and use these functions as needed. Note that if an interface has no HW address associated with it (this is, typically, the case for the loopback interface lo for example), then ioctl returns get_hw_addrs a HW address which is the equivalent of 00:00:00:00:00:00 . get_hw_addrs stores this in the appropriate field of its data structures as it would with any HW address returned by ioctl, but when prhwaddrs comes across such an address, it prints a blank line instead of its usual ‘HWaddr = xxxxxx:xx’. The ODR process creates one or more PF_PACKET sockets. You will need to try out PF_PACKET sockets for yourselves and familiarize yourselves with how they behave. If, when you read from the socket and provide a sockaddr_ll structure, the kernel returns to you the index of the interface on which the incoming frame was received, then one socket will be enough. Otherwise, somewhat in the manner of Assignment 2, you shall have to create a PF_PACKET socket for every interface of interest (which are all the interfaces of the node, excluding interfaces lo and eth0 ), and bind a socket to each interface. Furthermore, if the kernel also returns to you the source Ethernet address of the frame in the sockaddr_ll structure, then you can make do with SOCK_DGRAM type PF_PACKET sockets; otherwise you shall have to use SOCK_RAW type sockets (although I would prefer you to use SOCK_RAW type sockets anyway, even if it turns out you can make do with SOCK_DGRAM type). The socket(s) should have a protocol value (no larger than 0xffff so that it fits in two bytes; this value is given as a network-byte-order parameter in the call(s) to function socket) that identifies your ODR protocol. The <linux/if_ether.h> include file (i.e., the file /usr/include/linux/if_ether.h) contains protocol values defined for the standard protocols typically found on an Ethernet LAN, as well as other values such as ETH_P_ALL. You should set protocol to a value of your choice which is not a <linux/if_ether.h> value, but which is, hopefully, unique to yourself. Remember that you will all be running your code using the same root account on the vm1 , . . . . . , vm10 nodes. So if two of you happen to choose the same protocol value and happen to be running on the same vm node at the same time, your applications will receive each other’s frames. For that reason, try to choose a protocol value for the socket(s) that is likely to be unique to yourself (something based on your Stony Brook student ID number, for example). This value effectively becomes the protocol value for your implementation of ODR, as opposed to some other cse 533 student's implementation. Because your value of protocol is to be carried in the frame type field of the Ethernet frame header, the value chosen should be not less than 1536 (0x600) so that it is not misinterpreted as the length of an Ethernet 802.3 frame. Note from the man pages for packet(7) that frames are passed to and from the socket without any processing in the frame content by the device driver on the other side of the socket, except for calculating and tagging on the 4-byte CRC trailer for outgoing frames, and stripping that trailer before delivering incoming frames to the socket. Nevertheless, if you write a frame that is less than 60 bytes, the necessary padding is automatically added by the device driver so that the frame that is actually transmitted out is the minimum Ethernet size of 64 bytes. When reading from the socket, however, any such padding that was introduced into a short frame at the sending node to bring it up to the minimum frame size is not stripped off - it is included in what you receive from the socket (thus, the minimum number of bytes you receive should never be less than 60). Also, you will have to build the frame header for outgoing frames yourselves (assuming you use SOCK_RAW type sockets). Bear in mind that the field values in that header have to be in network order. The ODR process also creates a domain datagram socket for communication with application processes at the node, and binds the socket to a ‘well known’ sun_path name for the ODR service. Because it is dealing with fixed topologies, ODR is, by and large, considerably simpler than AODV. In particular, discovered routes are relatively stable and there is no need for all the paraphernalia that goes with the possibility of routes changing (such as maintenance of active nodes in the routing tables and timeout mechanisms; timeouts on reverse links; lifetime field in the RREP messages; etc.) Nor will we be implementing source_sequence_#s (in the RREQ messages), and dest_sequence_# (in RREQ and RREP messages). In reality, we should (though we will not, for the sake of simplicity, be doing so) implement some sort of sequence number mechanism, or some alternative mechanism such as split-horizon for example, if we are to avoid possible scenarios of routing loops in a “count to infinity” context (I shall explain this point in class). However, we want ODR to discover shortest-hop paths, and we want it to do so in a reasonably efficient manner. This necessitates having one or two aspects of its operations work in a different, possibly slightly more complicated, way than AODV does. ODR has several basic responsibilities : Build and maintain a routing table. For each destination in the table, the routing table structure should include, at a minimum, the next-hop node (in the form of the Ethernet address for that node) and outgoing interface index, the number of hops to the destination, and a timestamp of when the the routing table entry was made or last “reconfirmed” / updated. Note that a destination node in the table is to be identified only by its ‘canonical’ IP address, and not by any other IP addresses the node has. Generate a RREQ in response to a time client calling msg_send for a destination for which ODR has no route (or for which a route exists, but msg_send has the flag parameter set or the route has gone ‘stale’ – see below), and ‘flood’ the RREQ out on all the node’s interfaces (except for the interface it came in on and, of course, the interfaces eth0 and lo). Flooding is done using an Ethernet broadcast destination address (0xffffff:ff) in the outgoing frame header. Note that a copy of the broadcast packet is supposed to / might be looped back to the node that sends it (see p. 535 in the Stevens textbook). ODR will have to take care not to treat these copies as new incoming RREQs. Also note that ODR at the client node increments the broadcast_id every time it issues a new RREQ for any destination node. When a RREQ is received, ODR has to generate a RREP if it is at the destination node, or if it is at an intermediate node that happens to have a route (which is not ‘stale’ – see below) to the destination. Otherwise, it must propagate the RREQ by flooding it out on all the node’s interfaces (except the interface the RREQ arrived on). Note that as it processes received RREQs, ODR should enter the ‘reverse’ route back to the source node into its routing table, or update an existing entry back to the source node if the RREQ received shows a shorter-hop route, or a route with the same number of hops but going through a different neighbour. The timestamp associated with the table entry should be updated whenever an existing route is either “reconfirmed” or updated. Obviously, if the node is going to generate a RREP, updating an existing entry back to the source node with a more efficient route, or a same-hops route using a different neighbour, should be done before the RREP is generated. Unlike AODV, when an intermediate node receives a RREQ for which it generates a RREP, it should nevertheless continue to flood the RREQ it received if the RREQ pertains to a source node whose existence it has heretofore been unaware of, or the RREQ gives it a more efficient route than it knew of back to the source node (the reason for continuing to flood the RREQ is so that other nodes in the intranet also become aware of the existence of the source node or of the potentially more optimal reverse route to it, and update their tables accordingly). However, since an RREP for this RREQ is being sent by our node, we do not want other nodes who receive the RREQ propagated by our node, and who might be in a position to do so, to also send RREPs. So we need to introduce a field in the RREQ message, not present in the AODV specifications, which acts like a “RREP already sent” field. Our node sets this field before further propagating the RREQ and nodes receiving an RREQ with this field set do not send RREPs in response, even if they are in a position to do so. ODR may, of course, receive multiple, distinct instances of the same RREQ (the combination of source_addr and broadcast_id uniquely identifies the RREQ). Such RREQs should not be flooded out unless they have a lower hop count than instances of that RREQ that had previously been received. By the same token, if ODR is in a position to send out a RREP, and has already done so for this, now repeating, RREQ , it should not send out another RREP unless the RREQ shows a more efficient, previously unknown, reverse route back to the source node. In other words, ODR should not generate essentially duplicative RREPs, nor generate RREPs to instances of RREQs that reflect reverse routes to the source that are not more efficient than what we already have. Relay RREPs received back to the source node (this is done using the ‘reverse’ route entered into the routing table when the corresponding RREQ was processed). At the same time, a ‘forward’ path to the destination is entered into the routing table. ODR could receive multiple, distinct RREPs for the same RREQ. The ‘forward’ route entered in the routing table should be updated to reflect the shortest-hop route to the destination, and RREPs reflecting suboptimal routes should not be relayed back to the source. In general, maintaining a route and its associated timestamp in the table in response to RREPs received is done in the same manner described above for RREQs. Forward time client/server messages along the next hop. (The following is important – you will lose points if you do not implement it.) Note that such application payload messages (especially if they are the initial request from the client to the server, rather than the server response back to the client) can be like “free” RREPs, enabling nodes along the path from source (client) to destination (server) node to build a reverse path back to the client node whose existence they were heretofore unaware of (or, possibly, to update an existing route with a more optimal one). Before it forwards an application payload message along the next hop, ODR at an intermediate node (and also at the final destination node) should use the message to update its routing table in this way. Thus, calls to msg_send by time servers should never cause ODR at the server node to initiate RREQs, since the receipt of a time client request implies that a route back to the client node should now exist in the routing table. The only exception to this is if the server node has a staleness parameter of zero (see below). A routing table entry has associated with it a timestamp that gives the time the entry was made into the table. When a client at a node calls msg_send, and if an entry for the destination node already exists in the routing table, ODR first checks that the routing information is not ‘stale’. A stale routing table entry is one that is older than the value defined by the staleness parameter given as a command line argument to the ODR process when it is executed. ODR deletes stale entries (as well as non-stale entries when the flag parameter in msg_send is set) and initiates a route rediscovery by issuing a RREQ for the destination node. This will force periodic updating of the routing tables to take care of failed nodes along the current path, Ethernet addresses that might have changed, and so on. Similarly, as RREQs propagate through the intranet, existing stale table entries at intermediate nodes are deleted and new route discoveries propagated. As noted above when discussing the processing of RREQs and RREPs, the associated timestamp for an existing table entry is updated in response to having the route either “reconfirmed” or updated (this applies to both reverse routes, by virtue of RREQs received, and to forward routes, by virtue of RREPs). Finally, note that a staleness parameter of 0 essentially indicates that the discovered route will be used only once, when first discovered, and then discarded. Effectively, an ODR with staleness parameter 0 maintains no real routing table at all ; instead, it forces route discoveries at every step of its operation. As a practical matter, ODR should be run with staleness parameter values that are considerably larger than the longest RTT on the intranet, otherwise performance will degrade considerably (and collapse entirely as the parameter values approach 0). Nevertheless, for robustness, we need to implement a mechanism by which an intermediate node that receives a RREP or application payload message for forwarding and finds that its relevant routing table entry has since gone stale, can intiate a RREQ to rediscover the route it needs. RREQ, RREP, and time client/server request/response messages will all have to be carried as encapsulated ODR protocol messages that form the data payload of Ethernet frames. So we need to design the structure of ODR protocol messages. The format should contain a type field (0 for RREQ, 1 for RREP, 2 for application payload ). The remaining fields in an ODR message will depend on what type it is. The fields needed for (our simplified versions of AODV’s) RREQ and RREP should be fairly clear to you, but keep in mind that you need to introduce two extra fields: The “RREP already sent” bit or field in RREQ messages, as mentioned above. A “forced discovery” bit or field in both RREQ and RREP messages: When a client application forces route rediscovery, this bit should be set in the RREQ issued by the client node ODR. Intermediate nodes that are not the destination node but which do have a route to the destination node should not respond with RREPs to an RREQ which has the forced discovery field set. Instead, they should continue to flood the RREQ so that it eventually reaches the destination node which will then respond with an RREP. The intermediate nodes relaying such an RREQ must update their ‘reverse’ route back to the source node accordingly, even if the new route is less efficient (i.e., has more hops) than the one they currently have in their routing table. The destination node responds to the RREQ with an RREP in which this field is also set. Intermediate nodes that receive such a forced discovery RREP must update their ‘forward’ route to the destination node accordingly, even if the new route is less efficient (i.e., has more hops) than the one they currently have in their routing table. This behaviour will cause a forced discovery RREQ to be responded to only by the destination node itself and not any other node, and will cause intermediate nodes to update their routing tables to both source and destination nodes in accordance with the latest routing information received, to cover the possibility that older routes are no longer valid because nodes and/or links along their paths have gone down. A type 2, application payload, message needs to contain the following type of information : type = 2 ‘canonical’ IP address of source node ‘port’ number of source application process (This, of course, is not a real port number in the TCP/UDP sense, but simply a value that ODR at the source node uses to designate the sun_path name for the source application’s domain socket.) ‘canonical’ IP address of destination node ‘port’ number of destination application process (This is passed to ODR by the application process at the source node when it calls msg_send. Its designates the sun_path name for an application’s domain socket at the destination node.) hop count (This starts at 0 and is incremented by 1 at each hop so that ODR can make use of the message to update its routing table, as discussed above.) number of bytes in application message The fields above essentially constitute a ‘header’ for the ODR message. Note that fields which you choose to have carry numeric values (rather than ascii characters, for example) must be in network byte order. ODR-defined numeric-valued fields in type 0, RREQ, and type 1, RREP, messages must, of course, also be in network byte order. Also note that only the ‘canonical’ IP addresses are used for the source and destination nodes in the ODR header. The same has to be true in the headers for type 0, RREQ, and type 1, RREP, messages. The general rule is that ODR messages only carry ‘canonical’ IP node addresses. The last field in the type 2 ODR message is essentially the data payload of the message. application message given in the call to msg_send An ODR protocol message is encapsulated as the data payload of an Ethernet frame whose header it fills in as follows : source address = Ethernet address of outgoing interface of the current node where ODR is processing the message. destination address = Ethernet broadcast address for type 0 messages; Ethernet address of next hop node for type 1 & 2 messages. protocol field = protocol value for the ODR PF_PACKET socket(s). Last but not least, whenever ODR writes an Ethernet frame out through its socket, it prints out on stdout the message ODR at node vm i1 : sending frame hdr src vm i1 dest addr ODR msg type n src vm i2 dest vm i3 where addr is in presentation format (i.e., hexadecimal xxxxxx:xx) and gives the destination Ethernet address in the outgoing frame header. Other nodes in the message should be identified by their vm name. A message should be printed out for each packet sent out on a distinct interface. ODR and the API When the ODR process first starts, it must construct a table in which it enters all well-known ‘port’ numbers and their corresponding sun_path names. These will constitute permanent entries in the table. Thereafter, whenever it reads a message off its domain socket, it must obtain the sun_path name for the peer process socket and check whether that name is entered in the table. If not, it must select an ‘ephemeral’ ‘port’ value by which to designate the peer sun_path name and enter the pair < port value , sun_path name > into the table. Such entries cannot be permanent otherwise the table will grow unboundedly in time, with entries surviving for ever, beyond the peer processes’ demise. We must associate a time_to_live field with a non-permanent table entry, and purge the entry if nothing is heard from the peer for that amount of time. Every time a peer process for which a non-permanent table entry exists communicates with ODR, its time_to_live value should be reinitialized. Note that when ODR writes to a peer, it is possible for the write to fail because the peer does not exist : it could be a ‘well-known’ service that is not running, or we could be in the interval between a process with a non-permanent table entry terminating and the expiration of its time_to_live value. Notes A proper implementation of ODR would probably require that RREQ and RREP messages be backed up by some kind of timeout and retransmission mechanism since the network transmission environment is not reliable. This would considerably complicate the implementation (because at any given moment, a node could have multiple RREQs that it has flooded out, but for which it has still not received RREPs; the situation is further complicated by the fact that not all intermediate nodes receiving and relaying RREQs necessarily lie on a path to the destination, and therefore should expect to receive RREPs), and, learning-wise, would not add much to the experience you should have gained from Assignment 2.

0 comments    
105485 C libraries
(30565 libraries)
Go
(132908 libraries)
(72503 libraries)
(28530 libraries)
(37594 libraries)
C#
(64829 libraries)
(27487 libraries)
(47653 libraries)
(17537 libraries)
(13354 libraries)
(34853 libraries)
(19220 libraries)
(201750 libraries)
(20703 libraries)
Vue
(27652 libraries)
CSS
(108293 libraries)
(138934 libraries)
(85044 libraries)
(20387 libraries)
C++
(137302 libraries)
C
(105485 libraries)
(63727 libraries)
(84971 libraries)
(12012 libraries)
(83219 libraries)
PHP
(119123 libraries)
(189294 libraries)
(266027 libraries)
(10963 libraries)
Nim
(7227 libraries)
D
(13615 libraries)
(47359 libraries)
(3627 libraries)