Ticket #2531: dhcp.2.diff

File dhcp.2.diff, 5.8 KB (added by Adek336, 15 years ago)
  • src/servers/net/DHCPClient.cpp

     
    2121#include <sys/time.h>
    2222
    2323
     24#define LND do { ktrace_printf("DHCP: %s: %s: %d\n", __FILE__, __func__, __LINE__); } while(0)
     25
    2426// See RFC 2131 for DHCP, see RFC 1533 for BOOTP/DHCP options
    2527
    2628#define DHCP_CLIENT_PORT    68
     
    336338    fRunner(NULL),
    337339    fLeaseTime(0)
    338340{
     341    LND;
    339342    fStartTime = system_time();
    340343    fTransactionID = (uint32)fStartTime;
    341344
    342345    fStatus = get_mac_address(device, fMAC);
    343     if (fStatus < B_OK)
     346    if (fStatus < B_OK) {
     347        LND;
    344348        return;
     349    }
    345350
    346351    memset(&fServer, 0, sizeof(struct sockaddr_in));
    347352    fServer.sin_family = AF_INET;
    348353    fServer.sin_len = sizeof(struct sockaddr_in);
    349354    fServer.sin_port = htons(DHCP_SERVER_PORT);
     355    LND;
    350356}
    351357
    352358
    353359DHCPClient::~DHCPClient()
    354360{
     361    LND;
    355362    if (fStatus != B_OK)
    356363        return;
    357364
     
    374381status_t
    375382DHCPClient::Initialize()
    376383{
     384    LND;
    377385    fStatus = _Negotiate(INIT);
    378386    printf("DHCP for %s, status: %s\n", fDevice.String(), strerror(fStatus));
    379387    return fStatus;
     
    383391status_t
    384392DHCPClient::_Negotiate(dhcp_state state)
    385393{
     394    LND;
    386395    int socket = ::socket(AF_INET, SOCK_DGRAM, 0);
    387396    if (socket < 0)
    388397        return errno;
     
    453462
    454463    // receive loop until we've got an offer and acknowledged it
    455464
     465    LND;
     466
    456467    while (state != ACKNOWLEDGED) {
     468        LND;
    457469        char buffer[2048];
    458470        ssize_t bytesReceived = recvfrom(socket, buffer, sizeof(buffer),
    459471            0, NULL, NULL);
    460472        if (bytesReceived < 0 && errno == B_TIMED_OUT) {
     473            LND;
    461474            // depending on the state, we'll just try again
    462475            if (!_TimeoutShift(socket, timeout, tries)) {
     476                LND;
    463477                close(socket);
    464478                return B_TIMED_OUT;
    465479            }
     
    467481            if (state == INIT)
    468482                status = _SendMessage(socket, discover, broadcast);
    469483            else {
     484                LND;
    470485                status = _SendMessage(socket, request, state != RENEWAL
    471486                    ? broadcast : fServer);
    472487            }
    473488
    474489            if (status < B_OK)
    475490                break;
     491            LND;
    476492        } else if (bytesReceived < B_OK)
    477493            break;
     494        LND;
    478495
    479496        dhcp_message *message = (dhcp_message *)buffer;
    480497        if (message->transaction_id != htonl(fTransactionID)
    481498            || !message->HasOptions()
    482499            || memcmp(message->mac_address, discover.mac_address,
    483500                discover.hardware_address_length)) {
     501            LND;
    484502            // this message is not for us
    485503            continue;
    486504        }
     
    488506        switch (message->Type()) {
    489507            case DHCP_NONE:
    490508            default:
     509                LND;
    491510                // ignore this message
    492511                break;
    493512
    494513            case DHCP_OFFER:
    495514            {
     515                LND;
    496516                // first offer wins
    497517                if (state != INIT)
    498518                    break;
     
    526546
    527547            case DHCP_ACK:
    528548            {
     549                LND;
    529550                if (state != REQUESTING && state != REBINDING
    530551                    && state != RENEWAL)
    531552                    continue;
     553                LND;
    532554
    533555                // TODO: we might want to configure the stuff, don't we?
    534556                BMessage address;
     
    548570            }
    549571
    550572            case DHCP_NACK:
     573            LND;
    551574                if (state != REQUESTING)
    552575                    continue;
     576                LND;
    553577
    554578                // try again (maybe we should prefer other servers if this
    555579                // happens more than once)
     
    559583                break;
    560584        }
    561585    }
     586    LND;
    562587
    563588    close(socket);
    564589
     
    582607        fRenewalTime = (fLeaseTime - now) * 2/3 + now;
    583608        fRebindingTime = (fLeaseTime - now) * 5/6 + now;
    584609    }
     610    LND;
    585611
    586612    return status;
    587613}
     
    819845            dhcp_state state = _CurrentState();
    820846
    821847            bigtime_t next;
     848            LND;
    822849            if (_Negotiate(state) == B_OK) {
    823850                switch (state) {
    824851                    case RENEWAL:
  • src/servers/net/NetServer.cpp

     
    3737#include <string.h>
    3838#include <unistd.h>
    3939
     40#define LND do { ktrace_printf("DHCP: %s: %s: %d\n", __FILE__, __func__, __LINE__); } while(0)
    4041
     42
    4143static const char *kSignature = "application/x-vnd.haiku-net_server";
    4244
    4345
     
    485487status_t
    486488NetServer::_ConfigureInterface(int socket, BMessage& interface, bool fromMessage)
    487489{
     490    LND;
     491
    488492    const char *device;
    489493    if (interface.FindString("device", &device) != B_OK)
    490494        return B_BAD_VALUE;
     
    675679        }
    676680    }
    677681
     682    LND;
    678683    if (startAutoConfig) {
    679684        // start auto configuration
     685        LND;
    680686        AutoconfigLooper* looper = new AutoconfigLooper(this, device);
    681687        looper->Run();
    682688
     
    725731    address.AddBool("auto config", true);
    726732    interface.AddMessage("address", &address);
    727733
     734    LND;
     735
    728736    return _ConfigureInterface(socket, interface);
    729737}
    730738
     
    746754            continue;
    747755
    748756        if (S_ISBLK(stat.st_mode) || S_ISCHR(stat.st_mode)) {
     757            LND;
    749758            if (suggestedInterface != NULL
    750759                && suggestedInterface->RemoveName("device") == B_OK
    751760                && suggestedInterface->AddString("device", path.Path()) == B_OK
     
    782791            }
    783792        }
    784793
     794        LND;
    785795        _ConfigureInterface(socket, interface);
    786796    }
    787797}
     
    817827        address.AddString("address", "127.0.0.1");
    818828        interface.AddMessage("address", &address);
    819829
     830        LND;
    820831        _ConfigureInterface(socket, interface);
    821832    }
    822833
  • src/servers/net/AutoconfigLooper.cpp

     
    1818#include <sys/socket.h>
    1919#include <sys/sockio.h>
    2020
     21#define LND do { ktrace_printf("DHCP: %s: %s: %d\n", __FILE__, __func__, __LINE__); } while(0)
    2122
     23
    2224static const uint32 kMsgReadyToRun = 'rdyr';
    2325
    2426
     
    2729    fTarget(target),
    2830    fDevice(device)
    2931{
     32    LND;
    3033    BMessage ready(kMsgReadyToRun);
    3134    PostMessage(&ready);
    3235}
     
    4043void
    4144AutoconfigLooper::_ReadyToRun()
    4245{
     46    LND;
    4347    ifreq request;
    4448    if (!prepare_request(request, fDevice.String()))
    4549        return;
     50    LND;
    4651
    4752    // set IFF_CONFIGURING flag on interface
    4853
     
    5863    close(socket);
    5964
    6065    // start with DHCP
     66    LND;
    6167
    6268    DHCPClient* client = new DHCPClient(fTarget, fDevice.String());
    6369    AddHandler(client);