Kapitel 2: Installation und Verwendung des Azure RTOS NetX Duo DHCP-Clients (2024)

Artikel
09/22/2022
17Minuten Lesedauer

Dieses Kapitel enthält eine Beschreibung verschiedener Probleme im Zusammenhang mit der Installation, Einrichtung und Verwendung der DHCP-Clientkomponente von Azure RTOS NetX Duo.

Produktverteilung

Azure RTOS NetX Duo können Sie aus unserem öffentlichen Quellcoderepository unter https://github.com/azure-rtos/netxduo beziehen. Das Paket enthält die folgenden Dateien:

nxd_dhcp_client.h: Headerdatei für NetX Duo DHCP.
nxd_dhcp_client.c: C-Quelldatei für DHCP NetX Duo.
nxd_dhcp_client.pdf: Benutzerhandbuch für NetX Duo DHCP.
- demo_netxduo_dhcp.c: Demonstration des NetX Duo DHCP-Clients.
- demo_netxduo_multihome_dhcp_client.c: Demonstration des DHCP-Clients für NetX Duo DHCP an mehreren Schnittstellen.

DHCP-Installation

Um den NetX Duo DHCP-Client verwenden zu können, muss die gesamte zuvor genannte Distribution in das Verzeichnis kopiert werden, in dem auch NetX Duo installiert ist. Wenn NetX Duo z.B. im Verzeichnis \threadx\arm7\green installiert ist, sollten die Dateien nxd_dhcp_client.h und nxd_dhcp_client.c in dieses Verzeichnis kopiert werden.

Verwenden von DHCP

DHCP für NetX Duo lässt sich ganz einfach verwenden. Grundsätzlich muss der Anwendungscode nxd_dhcp_client.h einschließen, nachdem tx_api.h und nx_api.h eingeschlossen wurden, um ThreadX bzw. NetX Duo nutzen zu können. Sobald nxd_dhcp_client.h eingebunden ist, kann der Anwendungscode die weiter unten in diesem Handbuch beschriebenen DHCP-Funktionsaufrufe durchführen. Die Anwendung muss außerdem nxd_dhcp_client.c in den Buildprozess einschließen. Diese Datei muss auf dieselbe Weise kompiliert werden wie andere Anwendungsdateien, und ihre Objektform muss zusammen mit den Dateien der Anwendung verlinkt werden. Dies ist alles, was für die Verwendung von NetX DHCP erforderlich ist.

Beachten Sie, dass vor der Verwendung von DHCP die Aktivierung von UDP durch den Aufruf von nx_udp_enable erforderlich ist, da für DHCP NetX Duo UDP-Dienste verwendet werden.

Um eine zuvor zugewiesene IP-Adresse zu beziehen, kann der DHCP-Client den DHCP-Prozess mit der Anforderungsnachricht (Request) und der Option50 „Angeforderte IP-Adresse“ an den DHCP-Server einleiten. Der DHCP-Server antwortet entweder mit einer Nachricht des Typs ACK, wenn er dem Client die IP-Adresse gewährt, oder mit NACK, wenn er dies ablehnt. Im letzteren Fall startet der DHCP-Client den DHCP-Prozess im Zustand „Init“ neu, und zwar mit einer Nachricht des Typs „Discover“ und ohne angeforderte IP-Adresse. Die Hostanwendung erstellt zunächst den DHCP-Client und ruft dann den API-Dienst nx_dhcp_request_client_ip auf, um die angeforderte IP-Adresse festzulegen, bevor der DHCP-Prozess mit nx_dhcp_start gestartet wird. Ein Beispiel einer DHCP-Anwendung finden Sie an anderer Stelle in diesem Dokument, das weitere Einzelheiten enthält.

Im gebundenen Zustand

Während sich der DHCP-Client im gebundenen Zustand befindet, verarbeitet der DHCP-Clientthread den Clientzustand einmal pro Intervall (gemäß Festlegung von NX_DHCP_TIME_INTERVAL) und verringert die verbleibende Dauer der dem Client zugewiesenen IP-Lease. Wenn die Verlängerungszeit abgelaufen ist, wird der DHCP-Clientzustand in den Zustand RENEW geändert, in dem der Client eine Verlängerung vom DHCP-Server anfordert.

Senden von DHCP-Nachrichten an den Server

Der DHCP-Client verfügt über API-Dienste, mit denen die Hostanwendung eine Nachricht an den DHCP-Server senden kann. Beachten Sie, dass diese Dienste NICHT für die Hostanwendung gedacht sind, um das DHCP-Clientprotokoll manuell auszuführen.

Starten und Beenden des DHCP-Clients

Um den DHCP-Client unabhängig davon zu beenden, ob er einen gebundenen Zustand erreicht hat, ruft die Hostanwendung nx_dhcp_stop auf.

Um einen DHCP-Client neu zu starten, muss die Hostanwendung den DHCP-Client zunächst mit dem zuvor beschriebenen Dienst nx_dhcp_stop beenden. Danach kann der Host nx_dhcp_start aufrufen, um den DHCP-Client fortzusetzen. Wenn die Hostanwendung ein früheres DHCP-Clientprofil löschen möchte, das z.B. von einem früheren DHCP-Server in einem anderen Netzwerk bezogen wurde, muss die Hostanwendung nx_dhcp_reinitialize aufrufen, um diese Aufgabe intern vor dem Aufruf von nx_dhcp_start durchzuführen.

Eine typische Sequenz kann wie folgt aussehen:

nx_dhcp_stop(&my_dhcp);nx_dhcp_reinitialize(&my_dhcp);nx_dhcp_start(&my_dhcp);

Bei DHCP-Anwendungen, die nur an einer einzigen Schnittstelle ausgeführt werden, wird durch Beenden des DHCP-Clients auch der CLIENT-Timer von DHCP deaktiviert. Daher erfolgt keine Nachverfolgung der verbleibenden IP-Leasedauer mehr. Wenn Sie den DHCP-Client an einer bestimmten Schnittstelle beenden, wird der Timer des DHCP-Clients nicht deaktiviert, aber die Aktualisierung des Timers entsprechend der verbleibenden IP-Leasedauer an dieser Schnittstelle wird beendet.

Daher ist es nicht ratsam, den DHCP-Client zu beenden, es sei denn, die Hostanwendung erfordert einen Neustart oder Netzwerkwechsel.

Verwenden des DHCP-Clients mit AutoIP

Der DHCP-Client von NetX Duo arbeitet gleichzeitig mit dem AutoIP-Protokoll in Anwendungen, in denen DHCP und AutoIP eine Adresse garantieren, bei denen nicht garantiert ist, dass ein DHCP-Server verfügbar ist oder antwortet. Wenn der Host jedoch keinen Server ermitteln kann oder ihm keine IP-Adresse zugewiesen wird, kann er auf das AutoIP-Protokoll umstellen, um eine lokale IP-Adresse zu erhalten. Zuvor ist es jedoch ratsam, den DHCP-Client vorübergehend zu beenden, während AutoIP die Phasen „probe“ (Test) und „defense“ (Verteidigung) durchläuft. Sobald dem Host eine AutoIP-Adresse zugewiesen wurde, kann der DHCP-Client neu gestartet werden. Wenn ein DHCP-Server verfügbar wird, kann die IP-Adresse des Hosts die vom DHCP-Server angebotene IP-Adresse übernehmen, während die Anwendung ausgeführt wird.

AutoIP von NetX Duo bietet dem Host eine Benachrichtigung über eine Adressänderung, um seine Aktivitäten im Falle einer Änderung der IP-Adresse zu überwachen.

Paketverkettung

Zur effizienteren Nutzung von Paketpool und Arbeitsspeicherressourcen kann der DHCP-Client eingehende verkettete Pakete (Datagramme, die die Treiber-MTU überschreiten) vom Ethernet-Treiber behandeln. Wenn der Treiber über diese Fähigkeit verfügt, kann die Anwendung den Paketpool für den Empfang von Paketen festlegen, die unter den obligatorischen NX_DHCP_PACKET_PAYLOAD-Bytes liegen. NX_DHCP_PACKET_PAYLOAD sollte den physischen Netzwerkrahmen (typischerweise Ethernet) plus 548Byte DHCP-Nachrichtendaten sowie IP und UDP aufnehmen.

Beachten Sie, dass die Anwendung die Paketnutzdaten und die Anzahl der Pakete im Paketpool optimieren kann, der Teil des DHCP-Clients ist und zum Senden von DHCP-Nachrichten verwendet wird. Sie kann die Größe basierend auf der erwarteten Nutzung und Größe der DHCP-Clientnachrichten optimieren.

Kleines Beispielsystem

In der nachfolgenden Abbildung1.1 sehen Sie ein Beispiel für die Verwendung von NetX Duo. Die Eintragsfunktion für Anwendungsthreads my_thread_entry wird in Zeile 101 erstellt. Nach erfolgreicher Erstellung wird die DHCP-Verarbeitung mit dem Aufruf nx_dhcp_start in Zeile 108 initiiert. An diesem Punkt versucht der Threadtask des DHCP-Clients separat, einen DHCP-Server zu kontaktieren. Während dieses Vorgangs wartet der Anwendungscode in Zeile95 darauf, dass eine gültige IP-Adresse mithilfe des Diensts nx_ip_status_check (oder nx_ip_interface_status_check für eine sekundäre Schnittstelle) bei der IP-Instanz registriert wird. Dies erfolgt üblicherweise in einer Schleife mit einer kürzeren Warteoption.

Nach Zeile127 hat DHCP eine gültige IP-Adresse erhalten, und die Anwendung kann dann fortfahren und die TCP/IP-Dienste von NetX Duo wie gewünscht nutzen.

#include "tx_api.h"#include "nx_api.h"#include "nxd_dhcp_client.h"#define DEMO_STACK_SIZE 4096TX_THREAD my_thread;NX_PACKET_POOL my_pool;NX_IP my_ip;NX_DHCP my_dhcp;/* Define function prototypes. */void my_thread_entry(ULONG thread_input);void my_netx_driver(struct NX_IP_DRIVER_STRUCT *driver_req);/* Define main entry point. */intmain(){ /* Enter the ThreadX kernel. */ tx_kernel_enter();}/* Define what the initial system looks like. */void tx_application_define(void *first_unused_memory){CHAR *pointer;UINT status; /* Setup the working pointer. */ pointer = (CHAR *) first_unused_memory; /* Create “my_thread”. */ tx_thread_create(&my_thread, "my thread", my_thread_entry, 0, pointer, DEMO_STACK_SIZE, 2, 2, TX_NO_TIME_SLICE, TX_AUTO_START); pointer = pointer + DEMO_STACK_SIZE; /* Initialize the NetX Duo system. */ nx_system_initialize(); /* Create a packet pool. */ status = nx_packet_pool_create(&my_pool, "NetX Main Packet Pool", 1024, pointer, 64000); pointer = pointer + 64000; /* Check for pool creation error. */ if (status) error_counter++; /* Create an IP instance without an IP address. */ status = nx_ip_create(&my_ip, "My NetX IP Instance", IP_ADDRESS(0,0,0,0), 0xFFFFFF00, &my_pool, my_netx_driver, pointer, DEMO_STACK_SIZE, 1); pointer = pointer + DEMO_STACK_SIZE; /* Check for IP create errors. */ if (status) error_counter++; /* Enable ARP and supply ARP cache memory for my IP Instance. */ status = nx_arp_enable(&my_ip, (void *) pointer, 1024); pointer = pointer + 1024; /* Check for ARP enable errors. */ if (status) error_counter++; /* Enable UDP. */ status = nx_udp_enable(&my_ip); if (status) error_counter++; } /* Define my thread. */ void my_thread_entry(ULONG thread_input) { UINT status; ULONG actual_status; NX_PACKET *my_packet; /* Wait for the link to come up. */ do { /* Get the link status. */ status = nx_ip_status_check(&my_ip, NX_IP_LINK_ENABLED, &actual_status, 100); } while (status != NX_SUCCESS); /* Create a DHCP instance. */ status = nx_dhcp_create(&my_dhcp, &my_ip, "My DHCP"); /* Check for DHCP create error. */ if (status) error_counter++; /* Start DHCP. */ nx_dhcp_start(&my_dhcp); /* Check for DHCP start error. */ if (status) error_counter++; /* Wait for IP address to be resolved through DHCP. */ nx_ip_status_check(&my_ip, NX_IP_ADDRESS_RESOLVED, (ULONG *) &status, 100000); /* Check to see if we have a valid IP address. */ if (status) { error_counter++; return; } else { /* Yes, a valid IP address is now on lease… All NetX Duo services are available. } }

Umgebungen mit mehreren Servern

In Netzwerken mit mehreren DHCP-Servern akzeptiert der DHCP-Client die erste empfangene Nachricht des Typs „DHCP Server Offer“, wechselt in den Zustand „Request“ und ignoriert alle anderen erhaltenen Angebote.

ARP-Tests

Der DHCP-Client kann so konfiguriert werden, dass er nach der Zuweisung von IP-Adressen durch den DHCP-Server einen oder mehrere ARP-Tests sendet, um zu prüfen, ob die IP-Adresse nicht bereits verwendet wird. Der ARP-Testschritt wird von RFC2131 empfohlen und ist besonders wichtig in Umgebungen mit mehreren DHCP-Servern. Wenn die Hostanwendung die Option NX_DHCP_CLIENT_SEND_ARP_PROBE aktiviert (weitere Informationen zu zusätzlichen Optionen für ARP-Tests finden Sie unter Konfigurationsoptionen in Kapitel2), sendet der DHCP-Client einen „an sich selbst adressierten“ ARP-Test und wartet die angegebene Zeit auf eine Antwort. Wenn keine empfangen wird, wechselt der DHCP-Client in den Zustand „Gebunden“. Wenn eine Antwort empfangen wird, geht der DHCP-Client davon aus, dass die Adresse bereits verwendet wird. Er sendet automatisch eine DECLINE-Nachricht an den Server und initialisiert den Client neu, um die DHCP-Tests erneut aus dem INIT-Zustand zu starten. Dadurch wird der DHCP-Zustandsautomat neu gestartet, und der Client sendet eine weitere DISCOVER-Nachricht an den Server.

BOOTP-Protokoll

Der DHCP-Client unterstützt neben dem DHCP-Protokoll auch das BOOTP-Protokoll. Um diese Option zu aktivieren und BOOTP anstelle von DHCP zu verwenden, muss die Hostanwendung die Konfigurationsoption NX_DHCP_BOOTP_ENABLE festlegen. Die Hostanwendung kann weiterhin bestimmte IP-Adressen im BOOTP-Protokoll anfordern. Der DHCP-Client unterstützt jedoch nicht das Laden des Hostbetriebssystems, wie es bei BOOTP mitunter der Fall ist.

DHCP an einer sekundären Schnittstelle

Der DHCP-Client von NetXDuo kann an sekundären Schnittstellen statt an der standardmäßigen primären Schnittstelle ausgeführt werden.

Um den DHCP-Client von NetXDuo an einer sekundären Netzwerkschnittstelle auszuführen, muss die Hostanwendung den Schnittstellenindex des DHCP-Clients mithilfe des API-Diensts nx_dhcp_set_interface_index auf die sekundäre Schnittstelle festlegen. Die Schnittstelle muss bereits mit dem Dienst nx_ip_interface_attach an die primäre Netzwerkschnittstelle angefügt sein. Weitere Informationen zum Anfügen sekundärer Schnittstellen finden Sie im NetXDuo-Benutzerhandbuch.

Nachfolgend finden Sie ein Beispielsystem (Abbildung1.2), bei dem die Hostanwendung sich an ihrer sekundären Schnittstelle mit dem DHCP-Server verbindet. In Zeile65 wird die sekundäre Schnittstelle an den IP-Task mit einer IP-Adresse des Typs NULL angefügt. In Zeile104 wird, nachdem die DHCP-Clientinstanz erstellt wurde, der Index der DHCP-Clientschnittstelle durch den Aufruf von nx_dhcp_set_interface_index auf 1 festgelegt (d.h. den Versatz zur primären Schnittstelle, die selbst den Index 0 hat). Danach ist der DHCP-Client in Zeile108 startbereit.

#include "tx_api.h"#include "nx_api.h"#include "nxd_dhcp_client.h"#define DEMO_STACK_SIZE 4096TX_THREAD my_thread;NX_PACKET_POOL my_pool;NX_IP my_ip;NX_DHCP my_dhcp;/* Define function prototypes. */void my_thread_entry(ULONG thread_input);void my_netx_driver(struct NX_IP_DRIVER_STRUCT *driver_req);/* Define main entry point. */intmain(){ /* Enter the ThreadX kernel. */ tx_kernel_enter();}/* Define what the initial system looks like. */void tx_application_define(void *first_unused_memory){CHAR *pointer;UINT status; /* Setup the working pointer. */ pointer = (CHAR *) first_unused_memory; /* Create “my_thread”. */ tx_thread_create(&my_thread, "my thread", my_thread_entry, 0, pointer, DEMO_STACK_SIZE, 2, 2, TX_NO_TIME_SLICE, TX_AUTO_START); pointer = pointer + DEMO_STACK_SIZE; /* Initialize the NetX Duo system. */ nx_system_initialize(); /* Create a packet pool. */ status = nx_packet_pool_create(&my_pool, "NetX Main Packet Pool", 1024, pointer, 64000); pointer = pointer + 64000; /* Check for pool creation error. */ if (status) error_counter++; /* Create an IP instance without an IP address. */ status = nx_ip_create(&my_ip, "My NetX IP Instance", IP_ADDRESS(0,0,0,0), 0xFFFFFF00, &my_pool, my_netx_driver, pointer, STACK_SIZE, 1); pointer = pointer + DEMO_STACK_SIZE; /* Check for IP create errors. */ if (status) error_counter++; status = _nx_ip_interface_attach(&ip_0, "port_2", IP_ADDRESS(0, 0, 0,0), 0xFFFFFF00UL, my_netx_driver); /* Enable ARP and supply ARP cache memory for my IP Instance. */ status = nx_arp_enable(&my_ip, (void *) pointer, 1024); pointer = pointer + 1024; /* Check for ARP enable errors. */ if (status) error_counter++; /* Enable UDP. */ status = nx_udp_enable(&my_ip); if (status) error_counter++;}void my_thread_entry(ULONG thread_input){UINT status;ULONG status;NX_PACKET *my_packet; /* Wait for the link to come up. */ do { /* Get the link status. */ status = nx_ip_status_check(&my_ip,NX_IP_LINK_ENABLED,& status,100); } while (status != NX_SUCCESS); /* Create a DHCP instance. */ status = nx_dhcp_create(&my_dhcp, &my_ip, "My DHCP"); /* Check for DHCP create error. */ if (status) error_counter++; /* Set the DHCP client interface to the secondary interface. */ status = nx_dhcp_set_interface_index(&my_dhcp, 1); /* Start DHCP. */ nx_dhcp_start(&my_dhcp); /* Check for DHCP start error. */ if (status) error_counter++; /* Wait for IP address to be resolved through DHCP. */ nx_ip_status_check(&my_ip, NX_IP_ADDRESS_RESOLVED, (ULONG *) &status, 100000); /* Check to see if we have a valid IP address. */ if (status) { error_counter++; return; } else { /* Yes, a valid IP address is now on lease… All NetX Duo services are available.*/ }}

Gleichzeitiges Ausführen des DHCP-Clients an mehreren Schnittstellen

Um den DHCP-Client an mehreren Schnittstellen auszuführen, muss NX_MAX_PHYSICAL_INTERFACES in nx_api.h auf die Anzahl der physischen Schnittstellen festgelegt werden, die mit dem Gerät verbunden sind. Standardmäßig ist dieser Wert1 (d.h. die primäre Schnittstelle). Um eine zusätzliche Schnittstelle bei der IP-Instanz zu registrieren, verwenden Sie den Dienst nx_ip_interface_attach. Weitere Informationen zum Anfügen sekundärer Schnittstellen finden Sie im NetXDuo-Benutzerhandbuch.

Der nächste Schritt ist das Festlegen von NX_DHCP_CLIENT_MAX_RECORDS in nxd_dhcp_client.h auf die maximale Anzahl der Schnittstellen, die DHCP gleichzeitig ausführen sollen. Beachten Sie, dass NX_DHCP_CLIENT_MAX_RECORDS nicht gleich NX_MAX_PHYSICAL_INTERFACES sein muss. Beispielsweise kann NX_MAX_PHYSICAL_INTERFACES gleich 3 und NX_DHCP_CLIENT_MAX_RECORDS gleich 2 sein. Bei dieser Konfiguration können nur zwei Schnittstellen (und das können jederzeit zwei beliebige der drei physischen Schnittstellen sein) der drei physischen Schnittstellen DHCP zu einem beliebigen Zeitpunkt ausführen. DHCP-Clientdatensätze haben keine 1:1-Zuordnung zu Netzwerkschnittstellen, z.B. korreliert der Clientdatensatz1 nicht automatisch mit dem Index1 der physischen Schnittstelle.

NX_DHCP_CLIENT_MAX_RECORDS kann auch auf einen Wert größer als NX_MAX_PHYSICAL_INTERFACES festgelegt werden, aber dies würde nicht genutzte Clientdatensätze erzeugen und eine ineffiziente Nutzung des Arbeitsspeichers darstellen.

Bevor die Anwendung DHCP an einer Schnittstelle starten kann, muss sie diese Schnittstellen durch Aufrufen von nx_dhcp_interface_enable aktivieren. Beachten Sie, dass die Ausnahme die primäre Schnittstelle ist, die beim Aufruf von nx_dhcp_create automatisch aktiviert wird (und die mit dem nachstehend beschriebenen Dienst nx_dhcp_interface_disable deaktiviert werden kann).

Eine Schnittstelle kann jederzeit für DHCP deaktiviert werden, oder DHCP kann an dieser Schnittstelle unabhängig von anderen Schnittstellen, die DHCP ausführen, beendet werden.

Wie zuvor erwähnt, aktivieren Sie eine bestimmte Schnittstelle für DHCP mit dem Dienst nx_dhcp_interface_enable und geben den physischen Schnittstellenindex im Eingabeargument an. Es können Schnittstellen entsprechend dem Wert von NX_DHCP_CLIENT_MAX_RECORDS aktiviert werden, mit der einzigen Einschränkung, dass das Eingabeargument für den Schnittstellenindex kleiner als der Wert von NX_MAX_PHYSICAL_INTERFACES ist.

Starten Sie DHCP mit dem Dienst nx_dhcp_interface_start an einer bestimmten Schnittstelle. Mit dem Dienst nx_dhcp_start können Sie DHCP an allen aktivierten Schnittstellen starten. (Schnittstellen mit bereits gestartetem DHCP werden von nx_dhcp_start nicht beeinflusst.)

Mit dem Dienst nx_dhcp_interface_stop können Sie DHCP an einer Schnittstelle beenden. DHCP muss an dieser Schnittstelle bereits gestartet sein, oder es wird ein Fehlerstatus zurückgegeben. Mit dem Dienst nx_dhcp_stop können Sie DHCP an allen aktivierten Schnittstellen beenden. DHCP kann jederzeit unabhängig von anderen Schnittstellen beendet werden.

Die meisten vorhandenen DHCP-Clientdienste verfügen über eine "Schnittstellen"-Entsprechung, z. B. nx_dhcp_interface_release die schnittstellenspezifische Entsprechung von nx_dhcp_release ist. Wenn der DHCP-Client für eine einzelne Schnittstelle konfiguriert ist, führt er die gleiche Aktion aus.

Beachten Sie, dass nicht schnittstellenspezifische DHCP-Clientdienste in der Regel für alle Schnittstellen gelten, aber nicht für alle. Im letzteren Fall gilt der nicht schnittstellenspezifische Dienst für die erste DHCP-fähige Schnittstelle, die beim Durchsuchen der Liste der Schnittstellendatensätze des DHCP-Clients gefunden wird. Wie sich ein nicht schnittstellenspezifischer Dienst verhält, wenn mehrere Schnittstellen für DHCP aktiviert sind, erfahren Sie in Kapitel3 unter Beschreibung der Dienste.

In der nachstehenden Beispielsequenz hat die IP-Instanz zwei Netzwerkschnittstellen und führt DHCP zunächst an der sekundären Schnittstelle aus. Zu einem späteren Zeitpunkt startet sie DHCP an der primären Schnittstelle. Anschließend gibt sie die IP-Adresse an der primären Schnittstelle frei und startet DHCP an der primären Schnittstelle neu:

nx_dhcp_create(&my_dhcp_client); /* By default this enables primary interface for DHCP. */nx_dhcp_interface_enable(&my_dhcp_client, 1); /* Secondary interface is enabled. */nx_dhcp_interface_start(&my_dhcp_client, 1); /* DHCP is started on secondary interface. *//* Some time later… */nx_dhcp_interface_start(&my_dhcp_client, 0); /* DHCP is started on primary interface. */nx_dhcp_interface_release(&my_dhcp_client, 0); /* Some time later… */nx_dhcp_interface_start(&my_dhcp_client, 0); /* DHCP is restarted on primary interface. */

Eine vollständige Liste der schnittstellenspezifischen Dienste finden Sie in Kapitel3 unter Beschreibung der Dienste.

Konfigurationsoptionen

Vom Benutzer konfigurierbare DHCP-Optionen in nxd_dhcp_client.h ermöglichen der Hostanwendung die Feinabstimmung des DHCP-Clients auf ihre speziellen Anforderungen. Es folgt eine Liste dieser Parameter:

NX_DHCP_ENABLE_BOOTP: Falls festgelegt, aktiviert diese Option anstelle von DHCP das Protokoll BOOTP. Diese Option ist standardmäßig deaktiviert.
NX_DHCP_CLIENT_RESTORE_STATE: Ermöglicht, falls aktiviert, dem DHCP-Client, seinen aktuellen Status der DHCP-Clientlizenz zu speichern, einschließlich der verbleibenden Leasedauer, und diesen Status zwischen Neustarts der DHCP-Clientanwendung wiederherzustellen. Der Standardwert ist „deaktiviert“.
NX_DHCP_CLIENT_USER_CREATE_PACKET_POOL: Sofern festgelegt, erstellt der DHCP-Client keinen eigenen Paketpool. Die Hostanwendung muss den DHCP-Clientpaketpool mit dem Dienst nx_dhcp_packet_pool_set festlegen. Der Standardwert ist „deaktiviert“.
NX_DHCP_CLIENT_SEND_ARP_PROBE: Ermöglicht, falls aktiviert, dem DHCP-Client das Senden eines ARP-Tests nach der Zuweisung einer IP-Adresse, um sicherzustellen, dass die zugewiesene DHCP-Adresse nicht einem anderen Host gehört. Diese Option ist standardmäßig deaktiviert.
NX_DHCP_ARP_PROBE_WAIT: Legt die Zeit fest, die der DHCP-Client nach dem Senden eines ARP-Tests auf eine Antwort wartet. Der Standardwert ist eine Sekunde (1 x NX_IP_PERIODIC_RATE).
NX_DHCP_ARP_PROBE_MIN: Legt die Mindestabweichung des Intervalls zwischen dem Senden von ARP-Tests fest. Der Standardwert ist 1Sekunde.
NX_DHCP_ARP_PROBE_MAX: Legt die Höchstabweichung des Intervalls zwischen dem Senden von ARP-Tests fest. Der Standardwert ist 2Sekunden.
NX_DHCP_ARP_PROBE_NUM: Legt die Anzahl der gesendeten ARP-Tests fest, um festzustellen, ob die vom DHCP-Server zugewiesene IP-Adresse bereits in Gebrauch ist. Der Standardwert ist 3Tests.
NX_DHCP_RESTART_WAIT: Legt die Dauer fest, die der DHCP-Client wartet, um DHCP neu zu starten, wenn die dem DHCP-Client zugewiesene IP-Adresse bereits in Gebrauch ist. Der Standardwert ist 10Sekunden.
NX_DHCP_CLIENT_MAX_RECORDS: Gibt die maximale Anzahl von Schnittstellen-Datensätzen an, die in der DHCP-Clientinstanz gespeichert werden sollen. Ein Datensatz einer DHCP-Clientschnittstelle ist ein Datensatz des DHCP-Clients, der an einer bestimmten Schnittstelle läuft. Der Standardwert ist als Anzahl physischer Schnittstellen festgelegt (NX_MAX_PHYSICAL_INTERFACES).
NX_DHCP_CLIENT_SEND_MAX_DHCP_MESSAGE_OPTION: Ermöglicht, falls aktiviert, dem DHCP-Client das Senden der Option für die maximale DHCP-Nachrichtengröße. Diese Option ist standardmäßig deaktiviert.
NX_DHCP_CLIENT_ENABLE_HOST_NAME_CHECK: Ermöglicht, falls festgelegt, dem DHCP-Client, den eingegebenen Hostnamen beim Aufruf von nx_dhcp_create auf ungültige Zeichen oder Länge zu prüfen. Diese Option ist standardmäßig deaktiviert.
NX_DHCP_THREAD_PRIORITY: Priorität des DHCP-Threads. Standardmäßig gibt dieser Wert an, dass der DHCP-Thread mit Priorität 3 ausgeführt wird.
NX_DHCP_THREAD_STACK_SIZE: Größe des DHCP-Threadstapels. Die Standardgröße ist 2.048Bytes.
NX_DHCP_TIME_INTERVAL: Intervall in Sekunden, in dem die Ablauffunktion des DHCP-Clienttimers ausgeführt wird. Diese Funktion aktualisiert alle Timeouts im DHCP-Prozess, z.B. wenn Nachrichten erneut gesendet werden sollen oder der Zustand des DHCP-Clients geändert wurde. Standardmäßig beträgt dieser Wert 1Sekunde.
NX_DHCP_OPTIONS_BUFFER_SIZE: Größe des Puffers für die DHCP-Optionen. Standardmäßig beträgt dieser Wert 312Bytes.
NX_DHCP_PACKET_PAYLOAD: Gibt die Größe der Nutzlast des DHCP-Clientpakets in Bytes an. Der Standardwert ist NX_DHCP_MINIMUM_IP_DATAGRAM + Größe des physischen Headers. Die Größe des physischen Headers in einem drahtgebundenen Netzwerk entspricht normalerweise der Größe des Ethernet-Frames.
NX_DHCP_PACKET_POOL_SIZE: Gibt die Größe des DHCP-Clientpaketpools an. Der Standardwert ist (5 x NX_DHCP_PACKET_PAYLOAD), der vier Pakete plus Platz für den internen Mehraufwand für Paketpools bereitstellt.
NX_DHCP_MIN_RETRANS_TIMEOUT: Legt die Option für die Mindestwartezeit für den Empfang einer Antwort des DHCP-Servers auf eine Clientnachricht fest, bevor die Nachricht erneut gesendet wird. Der Standardwert sind die in RFC2131 empfohlenen 4Sekunden.
NX_DHCP_MAX_RETRANS_TIMEOUT: Legt die Option für die Höchstwartezeit für den Empfang einer Antwort des DHCP-Servers auf eine Clientnachricht fest, bevor die Nachricht erneut gesendet wird. Der Standardwert ist 64Sekunden.
NX_DHCP_MIN_RENEW_TIMEOUT: Gibt die Option für die Mindestwartezeit für den Empfang einer Nachricht des DHCP-Servers und das Senden einer Verlängerungsanforderung an, nachdem der DHCP-Client an eine IP-Adresse gebunden wurde. Der Standardwert beträgt 60 Sekunden. Der DHCP-Client verwendet jedoch die Ablaufzeiten für die Vorgänge„Verlängern“ und „Erneut binden“ der Nachricht des DHCP-Servers, bevor er das Mindesttimeout für die Verlängerung übernimmt.
NX_DHCP_TYPE_OF_SERVICE: Typ des für die UDP-Anforderungen von DHCP erforderlichen Diensts. Standardmäßig ist dieser Wert als NX_IP_NORMAL definiert, um einen normalen IP-Paketdienst anzuzeigen.
NX_DHCP_FRAGMENT_OPTION: Aktiviert die Fragmentierung für DHCP-UDP-Anforderungen. Standardmäßig ist dieser Wert NX_DONT_FRAGMENT, um die UDP-Fragmentierung von DHCP zu deaktivieren.
NX_DHCP_TIME_TO_LIVE: Gibt die Anzahl der Router an, die dieses Paket passieren kann, bevor es verworfen wird. Standardmäßig ist der Wert auf 0x80 festgelegt.
NX_DHCP_QUEUE_DEPTH: Gibt die maximale Tiefe der Empfangswarteschlange an. Standardmäßig ist der Wert auf 4 festgelegt.