workbench/devs/networks/nForce/handler.c

   1 /*
   2  * $Id$
   3  */
   4
   5 /*
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful, but
  12     WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14     General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  19     MA 02111-1307, USA.
  20 */
  21
  22 #define DEBUG 0
  23
  24 #include <string.h>
  25
  26 #include <exec/types.h>
  27 #include <exec/resident.h>
  28 #include <exec/io.h>
  29 #include <exec/ports.h>
  30 #include <exec/errors.h>
  31
  32 #include <aros/debug.h>
  33
  34 #include <devices/sana2.h>
  35 #include <devices/sana2specialstats.h>
  36 #include <devices/newstyle.h>
  37
  38 #include <utility/utility.h>
  39 #include <utility/tagitem.h>
  40 #include <utility/hooks.h>
  41
  42 #include <proto/exec.h>
  43 #include <proto/dos.h>
  44 #include <proto/battclock.h>
  45
  46 #include <stdlib.h>
  47
  48 #include "nforce.h"
  49 #include "unit.h"
  50 #include LC_LIBDEFS_FILE
  51
  52 #define KNOWN_EVENTS \
  53     (S2EVENT_ERROR | S2EVENT_TX | S2EVENT_RX | S2EVENT_ONLINE \
  54     | S2EVENT_OFFLINE | S2EVENT_BUFF | S2EVENT_HARDWARE | S2EVENT_SOFTWARE)
  55
  56 static BOOL CmdInvalid(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  57 static BOOL CmdRead(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  58 static BOOL CmdWrite(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  59 static BOOL CmdFlush(LIBBASETYPEPTR LIBBASE, struct IORequest *request);
  60 static BOOL CmdS2DeviceQuery(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  61 static BOOL CmdGetStationAddress(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  62 static BOOL CmdConfigInterface(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  63 static BOOL CmdBroadcast(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  64 static BOOL CmdTrackType(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  65 static BOOL CmdUntrackType(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  66 static BOOL CmdGetTypeStats(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  67 static BOOL CmdGetGlobalStats(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  68 static BOOL CmdDeviceQuery(LIBBASETYPEPTR LIBBASE, struct IOStdReq *request);
  69 static BOOL CmdOnEvent(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  70 static BOOL CmdReadOrphan(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  71 static BOOL CmdOnline(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  72 static BOOL CmdOffline(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  73 static BOOL CmdAddMulticastAddresses(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  74 static BOOL CmdDelMulticastAddresses(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  75
  76 static const UWORD supported_commands[] =
  77 {
  78     CMD_READ,
  79     CMD_WRITE,
  80     CMD_FLUSH,
  81     S2_DEVICEQUERY,
  82     S2_GETSTATIONADDRESS,
  83     S2_CONFIGINTERFACE,
  84     S2_ADDMULTICASTADDRESS,
  85     S2_DELMULTICASTADDRESS,
  86     S2_MULTICAST,
  87     S2_BROADCAST,
  88     S2_TRACKTYPE,
  89     S2_UNTRACKTYPE,
  90     S2_GETTYPESTATS,
  91 //    S2_GETSPECIALSTATS,
  92     S2_GETGLOBALSTATS,
  93     S2_ONEVENT,
  94     S2_READORPHAN,
  95     S2_ONLINE,
  96     S2_OFFLINE,
  97     NSCMD_DEVICEQUERY,
  98     S2_ADDMULTICASTADDRESSES,
  99     S2_DELMULTICASTADDRESSES,
 100     0
 101 };
 102
 103 void handle_request(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 104 {
 105     BOOL complete;
 106
 107     switch(request->ios2_Req.io_Command)
 108     {
 109         case CMD_READ:
 110             complete = CmdRead(LIBBASE, request);
 111             break;
 112
 113         case CMD_WRITE:
 114         case S2_MULTICAST:
 115             complete = CmdWrite(LIBBASE, request);
 116             break;
 117
 118         case CMD_FLUSH:
 119             complete = CmdFlush(LIBBASE, (struct IORequest *)request);
 120             break;
 121
 122         case S2_DEVICEQUERY:
 123             complete = CmdS2DeviceQuery(LIBBASE, request);
 124             break;
 125
 126         case S2_GETSTATIONADDRESS:
 127             complete = CmdGetStationAddress(LIBBASE, request);
 128             break;
 129
 130         case S2_CONFIGINTERFACE:
 131             complete = CmdConfigInterface(LIBBASE, request);
 132             break;
 133
 134         case S2_BROADCAST:
 135             complete = CmdBroadcast(LIBBASE, request);
 136             break;
 137
 138         case S2_TRACKTYPE:
 139             complete = CmdTrackType(LIBBASE, request);
 140             break;
 141
 142         case S2_UNTRACKTYPE:
 143             complete = CmdUntrackType(LIBBASE, request);
 144             break;
 145
 146         case S2_GETTYPESTATS:
 147             complete = CmdGetTypeStats(LIBBASE, request);
 148             break;
 149
 150         case S2_GETGLOBALSTATS:
 151             complete = CmdGetGlobalStats(LIBBASE, request);
 152             break;
 153
 154         case S2_ONEVENT:
 155             complete = CmdOnEvent(LIBBASE, request);
 156             break;
 157
 158         case S2_READORPHAN:
 159             complete = CmdReadOrphan(LIBBASE, request);
 160             break;
 161
 162         case S2_ONLINE:
 163             complete = CmdOnline(LIBBASE, request);
 164             break;
 165
 166         case S2_OFFLINE:
 167             complete = CmdOffline(LIBBASE, request);
 168             break;
 169
 170         case S2_ADDMULTICASTADDRESS:
 171         case S2_ADDMULTICASTADDRESSES:
 172             complete = CmdAddMulticastAddresses(LIBBASE, request);
 173             break;
 174
 175         case S2_DELMULTICASTADDRESS:
 176         case S2_DELMULTICASTADDRESSES:
 177             complete = CmdDelMulticastAddresses(LIBBASE, request);
 178             break;
 179
 180         case NSCMD_DEVICEQUERY:
 181             complete = CmdDeviceQuery(LIBBASE, (struct IOStdReq *)request);
 182             break;
 183
 184         default:
 185             complete = CmdInvalid(LIBBASE, request);
 186     }
 187
 188     if(complete && (request->ios2_Req.io_Flags & IOF_QUICK) == 0)
 189         ReplyMsg((APTR)request);
 190
 191     ReleaseSemaphore(&((struct NFUnit *)request->ios2_Req.io_Unit)->unit_lock);
 192 }
 193
 194 static BOOL CmdInvalid(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 195 {
 196     request->ios2_Req.io_Error = IOERR_NOCMD;
 197     request->ios2_WireError = S2WERR_GENERIC_ERROR;
 198
 199     return TRUE;
 200 }
 201
 202 static BOOL CmdRead(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 203 {
 204     struct NFUnit *unit;
 205     struct Opener *opener;
 206     BOOL complete = FALSE;
 207
 208     unit = (APTR)request->ios2_Req.io_Unit;
 209
 210     if((unit->flags & IFF_UP) != 0)
 211     {
 212         opener = request->ios2_BufferManagement;
 213         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 214         PutMsg(&opener->read_port, (struct Message *)request);
 215     }
 216     else
 217     {
 218         request->ios2_Req.io_Error = S2ERR_OUTOFSERVICE;
 219         request->ios2_WireError = S2WERR_UNIT_OFFLINE;
 220         complete = TRUE;
 221     }
 222
 223     /* Return */
 224
 225     return complete;
 226 }
 227
 228 static BOOL CmdWrite(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 229 {
 230     struct NFUnit *unit;
 231     BYTE error = 0;
 232     ULONG wire_error;
 233     BOOL complete = FALSE;
 234
 235     /* Check request is valid */
 236
 237     unit = (APTR)request->ios2_Req.io_Unit;
 238     if((unit->flags & IFF_UP) == 0)
 239     {
 240         error = S2ERR_OUTOFSERVICE;
 241         wire_error = S2WERR_UNIT_OFFLINE;
 242     }
 243     else if((request->ios2_Req.io_Command == S2_MULTICAST) &&
 244             ((request->ios2_DstAddr[0] & 0x1) == 0))
 245     {
 246         error = S2ERR_BAD_ADDRESS;
 247         wire_error = S2WERR_BAD_MULTICAST;
 248     }
 249
 250     /* Queue request for sending */
 251
 252     if(error == 0) {
 253         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 254         PutMsg(unit->request_ports[WRITE_QUEUE], (APTR)request);
 255     }
 256     else
 257     {
 258         request->ios2_Req.io_Error = error;
 259         request->ios2_WireError = wire_error;
 260         complete = TRUE;
 261     }
 262
 263     /* Return */
 264
 265     return complete;
 266 }
 267
 268 static BOOL CmdFlush(LIBBASETYPEPTR LIBBASE, struct IORequest *request)
 269 {
 270     FlushUnit(LIBBASE, (APTR)request->io_Unit, EVENT_QUEUE, IOERR_ABORTED);
 271     return TRUE;
 272 }
 273
 274 static BOOL CmdS2DeviceQuery(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 275 {
 276     struct NFUnit *unit = (APTR)request->ios2_Req.io_Unit;
 277     struct fe_priv *np = unit->nu_fe_priv;
 278     struct Sana2DeviceQuery *info;
 279     ULONG size_available, size;
 280
 281     /* Copy device info */
 282
 283     info = request->ios2_StatData;
 284     size = size_available = info->SizeAvailable;
 285     if(size > sizeof(struct Sana2DeviceQuery))
 286         size = sizeof(struct Sana2DeviceQuery);
 287
 288     CopyMem(&LIBBASE->nf_Sana2Info, info, size);
 289
 290     if ((np->linkspeed & NVREG_LINKSPEED_MASK) == NVREG_LINKSPEED_100)
 291         info->BPS = 100000000;
 292     else if ((np->linkspeed & NVREG_LINKSPEED_MASK) == NVREG_LINKSPEED_1000)
 293         info->BPS = 1000000000;
 294     else
 295         info->BPS = 10000000;
 296
 297     info->SizeAvailable = size_available;
 298     info->SizeSupplied = size;
 299
 300     /* Return */
 301
 302     return TRUE;
 303 }
 304
 305 static BOOL CmdGetStationAddress(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 306 {
 307     struct NFUnit *unit;
 308
 309     /* Copy addresses */
 310
 311     unit = (APTR)request->ios2_Req.io_Unit;
 312     CopyMem(unit->dev_addr, request->ios2_SrcAddr, ETH_ADDRESSSIZE);
 313     CopyMem(unit->org_addr, request->ios2_DstAddr, ETH_ADDRESSSIZE);
 314
 315     /* Return */
 316
 317     return TRUE;
 318 }
 319
 320 static BOOL CmdConfigInterface(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 321 {
 322     struct NFUnit *unit;
 323
 324     /* Configure adapter */
 325
 326     unit = (APTR)request->ios2_Req.io_Unit;
 327     if((unit->flags & IFF_CONFIGURED) == 0)
 328     {
 329         CopyMem(request->ios2_SrcAddr, unit->dev_addr, ETH_ADDRESSSIZE);
 330         unit->set_mac_address(unit);
 331         unit->flags |= IFF_CONFIGURED;
 332     }
 333     else
 334     {
 335         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 336         request->ios2_WireError = S2WERR_IS_CONFIGURED;
 337     }
 338
 339     /* Return */
 340
 341     return TRUE;
 342 }
 343
 344 static BOOL CmdBroadcast(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 345 {
 346     /* Fill in the broadcast address as destination */
 347
 348     memset(request->ios2_DstAddr, 0xff, 6);
 349
 350     /* Queue the write as normal */
 351
 352     return CmdWrite(LIBBASE, request);
 353 }
 354
 355 static BOOL CmdTrackType(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 356 {
 357     struct NFUnit *unit;
 358     struct Opener *opener;
 359     ULONG packet_type, wire_error=0;
 360     struct TypeTracker *tracker;
 361     struct TypeStats *initial_stats;
 362     BYTE error = 0;
 363
 364     unit = (APTR)request->ios2_Req.io_Unit;
 365     packet_type = request->ios2_PacketType;
 366
 367     /* Get global tracker */
 368
 369     tracker = (struct TypeTracker *)
 370         FindTypeStats(LIBBASE, unit, &unit->type_trackers, packet_type);
 371
 372     if(tracker != NULL)
 373         tracker->user_count++;
 374     else
 375     {
 376         tracker =
 377             AllocMem(sizeof(struct TypeTracker), MEMF_PUBLIC|MEMF_CLEAR);
 378         if(tracker != NULL)
 379         {
 380             tracker->packet_type = packet_type;
 381             tracker->user_count = 1;
 382
 383             Disable();
 384             AddTail((APTR)&unit->type_trackers, (APTR)tracker);
 385             Enable();
 386         }
 387    }
 388
 389     /* Store initial figures for this opener */
 390
 391     opener = request->ios2_BufferManagement;
 392     initial_stats = FindTypeStats(LIBBASE, unit, &opener->initial_stats, packet_type);
 393
 394     if(initial_stats != NULL)
 395     {
 396         error = S2ERR_BAD_STATE;
 397         wire_error = S2WERR_ALREADY_TRACKED;
 398     }
 399
 400     if(error == 0)
 401     {
 402         initial_stats = AllocMem(sizeof(struct TypeStats), MEMF_PUBLIC);
 403         if(initial_stats == NULL)
 404         {
 405             error = S2ERR_NO_RESOURCES;
 406             wire_error = S2WERR_GENERIC_ERROR;
 407         }
 408     }
 409
 410     if(error == 0)
 411     {
 412         CopyMem(tracker, initial_stats, sizeof(struct TypeStats));
 413         AddTail((APTR)&opener->initial_stats, (APTR)initial_stats);
 414     }
 415
 416     /* Return */
 417
 418     request->ios2_Req.io_Error = error;
 419     request->ios2_WireError = wire_error;
 420     return TRUE;
 421 }
 422
 423 static BOOL CmdUntrackType(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 424 {
 425     struct NFUnit *unit;
 426     struct Opener *opener;
 427     ULONG packet_type;
 428     struct TypeTracker *tracker;
 429     struct TypeStats *initial_stats;
 430
 431     unit = (APTR)request->ios2_Req.io_Unit;
 432     packet_type = request->ios2_PacketType;
 433
 434     /* Get global tracker and initial figures */
 435
 436     tracker = (struct TypeTracker *)
 437         FindTypeStats(LIBBASE, unit, &unit->type_trackers, packet_type);
 438     opener = request->ios2_BufferManagement;
 439     initial_stats = FindTypeStats(LIBBASE, unit, &opener->initial_stats, packet_type);
 440
 441     /* Decrement tracker usage and free unused structures */
 442
 443     if(initial_stats != NULL)
 444     {
 445         if((--tracker->user_count) == 0)
 446         {
 447             Disable();
 448             Remove((APTR)tracker);
 449             Enable();
 450             FreeMem(tracker, sizeof(struct TypeTracker));
 451         }
 452
 453         Remove((APTR)initial_stats);
 454         FreeMem(initial_stats, sizeof(struct TypeStats));
 455     }
 456     else
 457     {
 458         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 459         request->ios2_WireError = S2WERR_NOT_TRACKED;
 460     }
 461
 462     /* Return */
 463
 464     return TRUE;
 465 }
 466
 467 static BOOL CmdGetTypeStats(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 468 {
 469     struct NFUnit *unit;
 470     struct Opener *opener;
 471     ULONG packet_type;
 472     struct TypeStats *initial_stats, *tracker;
 473     struct Sana2PacketTypeStats *stats;
 474
 475     unit = (APTR)request->ios2_Req.io_Unit;
 476     packet_type = request->ios2_PacketType;
 477
 478     /* Get global tracker and initial figures */
 479
 480     tracker = FindTypeStats(LIBBASE, unit, &unit->type_trackers, packet_type);
 481     opener = request->ios2_BufferManagement;
 482     initial_stats = FindTypeStats(LIBBASE, unit, &opener->initial_stats, packet_type);
 483
 484     /* Copy and adjust figures */
 485     if(initial_stats != NULL)
 486     {
 487         stats = request->ios2_StatData;
 488         CopyMem(&tracker->stats, stats, sizeof(struct Sana2PacketTypeStats));
 489         stats->PacketsSent -= initial_stats->stats.PacketsSent;
 490         stats->PacketsReceived -= initial_stats->stats.PacketsReceived;
 491         stats->BytesSent -= initial_stats->stats.BytesSent;
 492         stats->BytesReceived -= initial_stats->stats.BytesReceived;
 493         stats->PacketsDropped -= initial_stats->stats.PacketsDropped;
 494     }
 495     else
 496     {
 497         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 498         request->ios2_WireError = S2WERR_NOT_TRACKED;
 499     }
 500
 501     /* Return */
 502
 503     return TRUE;
 504 }
 505
 506 static BOOL CmdGetGlobalStats(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 507 {
 508     struct NFUnit *unit;
 509
 510     /* Update and copy stats */
 511
 512     unit = (APTR)request->ios2_Req.io_Unit;
 513     CopyMem(&unit->stats, request->ios2_StatData,
 514         sizeof(struct Sana2DeviceStats));
 515
 516     /* Return */
 517
 518     return TRUE;
 519 }
 520
 521 static BOOL CmdDeviceQuery(LIBBASETYPEPTR LIBBASE, struct IOStdReq *request)
 522 {
 523     struct NSDeviceQueryResult *info;
 524
 525     /* Set structure size twice */
 526
 527     info = request->io_Data;
 528     request->io_Actual = info->SizeAvailable =
 529         offsetof(struct NSDeviceQueryResult, SupportedCommands) + sizeof(APTR);
 530
 531     /* Report device details */
 532
 533     info->DeviceType = NSDEVTYPE_SANA2;
 534     info->DeviceSubType = 0;
 535
 536     info->SupportedCommands = (APTR)supported_commands;
 537
 538     /* Return */
 539
 540     return TRUE;
 541 }
 542
 543 static BOOL CmdOnEvent(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 544 {
 545     struct NFUnit *unit;
 546     ULONG events, wanted_events;
 547     BOOL complete = FALSE;
 548
 549     /* Check if we understand the event types */
 550
 551     unit = (APTR)request->ios2_Req.io_Unit;
 552     wanted_events = request->ios2_WireError;
 553     if((wanted_events & ~KNOWN_EVENTS) != 0)
 554     {
 555         request->ios2_Req.io_Error = S2ERR_NOT_SUPPORTED;
 556         events = S2WERR_BAD_EVENT;
 557     }
 558     else
 559     {
 560         if((unit->flags & IFF_UP) != 0)
 561             events = S2EVENT_ONLINE;
 562         else
 563             events = S2EVENT_OFFLINE;
 564
 565         events &= wanted_events;
 566     }
 567
 568     /* Reply request if a wanted event has already occurred */
 569
 570     if(events != 0)
 571     {
 572         request->ios2_WireError = events;
 573         complete = TRUE;
 574     }
 575     else
 576     {
 577         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 578         PutMsg(unit->request_ports[EVENT_QUEUE], (APTR)request);
 579     }
 580
 581     /* Return */
 582
 583     return complete;
 584 }
 585
 586 static BOOL CmdReadOrphan(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 587 {
 588     struct NFUnit *unit;
 589     BYTE error = 0;
 590     ULONG wire_error;
 591     BOOL complete = FALSE;
 592
 593     /* Check request is valid */
 594
 595     unit = (APTR)request->ios2_Req.io_Unit;
 596     if((unit->flags & IFF_UP) == 0)
 597     {
 598         error = S2ERR_OUTOFSERVICE;
 599         wire_error = S2WERR_UNIT_OFFLINE;
 600     }
 601
 602     /* Queue request */
 603
 604     if(error == 0)
 605     {
 606         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 607         PutMsg(unit->request_ports[ADOPT_QUEUE], (struct Message *)request);
 608     }
 609     else
 610     {
 611         request->ios2_Req.io_Error = error;
 612         request->ios2_WireError = wire_error;
 613         complete = TRUE;
 614     }
 615
 616     /* Return */
 617
 618     return complete;
 619 }
 620
 621 static BOOL CmdOnline(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 622 {
 623     struct NFUnit *unit = (struct NFUnit *)request->ios2_Req.io_Unit;
 624     BYTE error = 0;
 625     ULONG wire_error = 0;
 626     UWORD i;
 627
 628     /* Check request is valid */
 629     if((unit->flags & IFF_CONFIGURED) == 0)
 630     {
 631         error = S2ERR_BAD_STATE;
 632         wire_error = S2WERR_NOT_CONFIGURED;
 633     }
 634
 635     /* Clear global and special stats and put adapter back online */
 636
 637     if((error == 0) && ((unit->flags & IFF_UP) == 0))
 638     {
 639         unit->stats.PacketsReceived = 0;
 640         unit->stats.PacketsSent = 0;
 641         unit->stats.BadData = 0;
 642         unit->stats.Overruns = 0;
 643         unit->stats.UnknownTypesReceived = 0;
 644         unit->stats.Reconfigurations = 0;
 645
 646         for(i = 0; i < STAT_COUNT; i++)
 647             unit->special_stats[i] = 0;
 648
 649         if (unit->start(unit))
 650         {
 651             error = S2ERR_OUTOFSERVICE;
 652             wire_error = S2WERR_GENERIC_ERROR;
 653         }
 654     }
 655
 656     /* Return */
 657
 658     request->ios2_Req.io_Error = error;
 659     request->ios2_WireError = wire_error;
 660     return TRUE;
 661 }
 662
 663 static BOOL CmdOffline(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 664 {
 665     struct NFUnit *unit;
 666
 667     /* Put adapter offline */
 668
 669     unit = (APTR)request->ios2_Req.io_Unit;
 670     if((unit->flags & IFF_UP) != 0)
 671         unit->stop(unit);
 672
 673     /* Return */
 674     return TRUE;
 675 }
 676
 677 static BOOL CmdAddMulticastAddresses(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 678 {
 679     struct NFUnit *unit;
 680     UBYTE *lower_bound, *upper_bound;
 681
 682     unit = (APTR)request->ios2_Req.io_Unit;
 683
 684     lower_bound = request->ios2_SrcAddr;
 685     if(request->ios2_Req.io_Command == S2_ADDMULTICASTADDRESS)
 686         upper_bound = lower_bound;
 687     else
 688         upper_bound = request->ios2_DstAddr;
 689
 690     if(!AddMulticastRange(LIBBASE, unit, lower_bound, upper_bound))
 691     {
 692         request->ios2_Req.io_Error = S2ERR_NO_RESOURCES;
 693         request->ios2_WireError = S2WERR_GENERIC_ERROR;
 694     }
 695
 696     /* Return */
 697
 698     return TRUE;
 699 }
 700
 701 static BOOL CmdDelMulticastAddresses(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 702 {
 703     struct NFUnit *unit;
 704     UBYTE *lower_bound, *upper_bound;
 705
 706     unit = (APTR)request->ios2_Req.io_Unit;
 707
 708     lower_bound = request->ios2_SrcAddr;
 709     if(request->ios2_Req.io_Command == S2_DELMULTICASTADDRESS)
 710         upper_bound = lower_bound;
 711     else
 712         upper_bound = request->ios2_DstAddr;
 713
 714     if(!RemMulticastRange(LIBBASE, unit, lower_bound, upper_bound))
 715     {
 716         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 717         request->ios2_WireError = S2WERR_BAD_MULTICAST;
 718     }
 719
 720     /* Return */
 721
 722     return TRUE;
 723 }