PC Press: Internet/PC_PRESS.ISO/software/dos/misc/inar-100.exe/SRC/PCROUTE/IP.INC

Text File | 1995-05-21 | 34.7 KB | 1,128 lines

;;*************************************************************************
;;                         ip.inc       ip.inc
;;*************************************************************************
;;
;;  Copyright (C) 1989 Northwestern University, Vance Morrison
;;
;;
;; Permission to view, compile, and modify for LOCAL (intra-organization)
;; USE ONLY is hereby granted, provided that this copyright and permission
;; notice appear on all copies.  Any other use by permission only.
;;
;; Northwestern University makes no representations about the suitability
;; of this software for any purpose.  It is provided "as is" without expressed
;; or implied warranty.  See the copywrite notice file for complete details.
;;
;;*****************************************************************************
;;
;; Routines provided by this module
;;
;;   IP_DECLARE name, router, dls, icmp
;;   IP_DEFINE name
;;   IP_R_READ name, proto, code_label
;;   IP_R_RETURN name
;;   IP_R_SRC_in_ES_out_AX_BX_const_CX_DX_BP_SI_DI_ES name
;;   IP_R_DST_in_ES_out_AX_BX_const_CX_DX_BP_SI_DI_ES name
;;   IP_R_BROAD_const_AX_BX_CX_DX_BP_SI_DI_ES name, broadcast
;;   IP_R_HEADER_in_ES_out_SI_const_BX_CX_DX_BP_DI_ES name
;;   IP_W_ACCESS_in_AX_BX_CX_DL_out_AX_DI_ES name
;;   IP_W_WRITE_in_CX name
;;   IP_COMP_NET_in_AX_BX_out_AX_BX_const_CX_DX_BP_SI_DI_ES
;;   IP_SET_SRC_in_AX_BX_const_AX_BX_CX_DX_BP_SI_DI_ES name
;;
;;  Variables Provided by this Module (READ ONLY!!!)
;;
;;  ip_&name&_dls           ;; 1..dls are the names of the IP_DL objects
;;
;;*****************************************************************************

;; IP packet header def

;; masks for the Flag field
IP_DONT_FRAG    = 4000H
IP_MORE_FRAG    = 2000H
SWAPPED_IP_DONT_FRAG    = 40H
SWAPPED_IP_MORE_FRAG    = 20H
SWAPPED_IP_IS_FRAG      = 0FF3FH
SWAPPED_IP_FRAG_OFFSET  = 0FF1FH

ip      STRUC               ;; and IP packet
    ip_ver_size     DB ?
    ip_tos          DB ?
    ip_length       DW ?
    ip_id           DW ?
    ip_frag         DW ?
    ip_ttl          DB ?
    ip_proto        DB ?
    ip_check        DW ?
    ip_src          DD ?
    ip_dst          DD ?
ip  ENDS


ip_data  STRUC
    ip_write_dst    DD ?
    ip_write_src    DD ?
    ip_write_off    DW ?
    ip_write_seg    DW ?
    ip_write_gate   DD ?
    ip_write_proto  DB ?
    ip_write_dl     DB ?
    ip_write_id     DW ?
    ip_packet       DW (dl_ip_max_mtu/2 + 16) dup (0)
    ip_header       DW 32 dup (0)

    ip_broadcast    DB ?
    ip_read_head    DW ?
    ip_read_jmp     DW 32 dup (0)
ip_data  ENDS


;;******************************************************************************
;;   IP_DECLARE   name, dls
;;      IP_DECLARE declares a network ojbect that will route packets
;;      using 'router' as its routing table to the Data Link objects
;;      1..dls.
;;
IP_DECLARE MACRO name, router, dls, icmp

    .DATA
    ip_&name&_dls = dls
    ip_&name&_router = router
    ip_&name&_icmp = icmp
    global ip_&name&_data:ip_data

    .CODE
    IRP idx, <1,2,3,4,5,6,7,8>
    if idx le ip_&name&_dls
        IP_DECLARE_HELPER name, idx
    endif
    endm

    global ip_&name&_read_packet:near
    global ip_&name&_prot_unreach:near
    global ip_&name&_w_access:near
    global ip_&name&_w_write:near
    global ip_&name&_real_define:near
    global route_&name&_real_find:near
ENDM

IP_DECLARE_HELPER MACRO name, dl
    global ip_&name&_dl_&dl&_read_start:near
ENDM


;;*****************************************************************************
;;   IP_DEFINE name
;;       IP_DEFINE defines all of the data structures needed by IP and
;;       initializes them.
;;
IP_DEFINE MACRO name
    call ip_&name&_real_define
ENDM

IFDEF IP_REAL_DEFINE_NEEDED
IP_REAL_DEFINE MACRO name
    local around, skip
    .errb <name>

ifdef ip_&name&_dls

    .DATA
ip_&name&_data   ip_data  <>

    .CODE
    ip_&name&_real_define:
    jmp around                  ;; declare the 'this node' IP packet processor
        ip_&name&_read_packet:
            IP_PACKET_in_BX_CX_ES name
            RET

        ip_&name&_prot_unreach:
            IP_R_BROAD_const_AX_BX_CX_DX_BP_SI_DI_ES name, skip
            IP_R_HEADER_in_ES_out_SI_const_BX_CX_DX_BP_DI_ES name
            ICMP_ERROR_in_SI_ES %ip_&name&_icmp, ICMP_UNREACHABLE, ICMP_UNREACH_PROTO, name
            skip:
            RET

        ip_&name&_w_access:
            IP_REAL_W_ACCESS_in_AX_BX_CX_DL_out_AX_DI_ES name
            RET

        ip_&name&_w_write:
            IP_REAL_W_WRITE_in_CX name, %ip_&name&_w_write
            RET

        route_&name&_real_find:
            ROUTE_REAL_FIND_in_AX_BX_SI_DI_out_AX_BX_DX_DI_const_CX_BP_ES name
            RET
    around:
        ;; initialize the jump table
    mov AX, DS                              ;; initialize jump table
    mov ES, AX
    mov DI, offset ip_&name&_data.ip_read_jmp
    mov AX, offset ip_&name&_prot_unreach
    mov CX, 32
    rep
    stosw

        ;; do all per DL initilization
    IRP idx, <1,2,3,4,5,6,7,8>
    if idx le ip_&name&_dls
        IP_INIT_DL name, idx
    endif
    endm

    RET
endif
ENDM
ENDIF ; IP_REAL_DEFINE_NEEDED


;;*****************************************************************************
;; IP_R_READ name, proto, code_label
;;      IP_READ declares that the code starting at 'code_label' should
;;      be called when a IP packet with protocol 'proto' is read in
;;      The data in the IP packet is passed to the object in BX:ES the
;;      protocol type in AX and the length of the data in CX.
;;      When the code is done it should execute a RET instruction
;;      If the source address is requires IP_R_SRC should be called
;;
IP_R_READ MACRO name, proto, code_label
   .errb <code_label>

    if proto ge 32
        .err
        %out IP protocol out of range
    endif
    mov word ptr ip_&name&_data.ip_read_jmp+2*(proto), offset code_label
ENDM

;;*****************************************************************************
;; IP_R_SRC_in_ES_out_AX_BX name
;;      IP_R_SRC returns the source of the IP data packet in segment ES
;;      that was given to the IP_R_READ routine.  The IP address is put in
;;      AX,BX
;;
IP_R_SRC_in_ES_out_AX_BX_const_CX_DX_BP_SI_DI_ES MACRO name
   .errb <name>

   push SI
   IP_R_HEADER_in_ES_out_SI_const_BX_CX_DX_BP_DI_ES name
   add SI, ip_src
   mov AX, word ptr ES:[SI]
   mov BX, word ptr ES:[SI+2]
   pop SI
ENDM

;;*****************************************************************************
;; IP_R_DST_in_ES_out_AX_BX name
;;      IP_R_DST returns the destination of the IP data packet in segment
;;      ES that was given to the IP_R_READ routine.  The IP address is
;;      put in AX,BX.
;;
IP_R_DST_in_ES_out_AX_BX_const_CX_DX_BP_SI_DI_ES MACRO name
   .errb <name>

   push SI
   IP_R_HEADER_in_ES_out_SI_const_BX_CX_DX_BP_DI_ES name
   add SI, ip_dst
   mov AX, word ptr ES:[SI]
   mov BX, word ptr ES:[SI+2]
   pop SI
ENDM

;;*****************************************************************************
;; IP_R_BROAD name, broadcast
;;      IP_R_BROAD jumps to 'broadcast' if the current IP packet is a
;;      broadcast.
;;
IP_R_BROAD_const_AX_BX_CX_DX_BP_SI_DI_ES MACRO name, broadcast
   .errb <name>

    cmp ip_&name&_data.ip_broadcast, 0
    jnz broadcast
ENDM

;;*****************************************************************************
;;   IP_R_HEADER_in_ES_out_SI_const_BX_CX_DX_BP_DI_ES name
;; IP_R_HEADER_in_SI_ES_out_DI returns the IP header for the packet pointed
;; to by SI:ES.  This routine must only be called in the routine specified
;; in R_READ.  (this is meant so that you can send ICMP packets)
;;
IP_R_HEADER_in_ES_out_SI_const_BX_CX_DX_BP_DI_ES MACRO name
   .errb <name>

    mov SI, word ptr ip_&name&_data.ip_read_head        ;; save header pointer
ENDM



;;*****************************************************************************
;; IP_W_ACCESS_in_AX_BX_CX_DL_out_AX_DI_ES name
;;      IP_W_ACCESS retrieves a buffer to write the data for an IP packet.
;;      AX,BX holds the destination IP address of the packet and DL holds
;;      the protocol number of the packet.   The output buffer is returned
;;      in DI:ES.  This routine might fail if CX exceeds the MTU of the
;;      interface.  Thus it is only guarenteed to succeed when
;;      CX <= dl_ip_min_mtu.  AX is 0 if everything was successful.
;;
IP_W_ACCESS_in_AX_BX_CX_DL_out_AX_DI_ES MACRO name
    local call_OK

    CALL ip_&name&_w_access
ENDM

;;*****************************************************************************
;; IP_REAL_W_ACCESS is the real provider of the W_ACCESS service.
;;
IFDEF IP_REAL_DEFINE_NEEDED
IP_REAL_W_ACCESS_in_AX_BX_CX_DL_out_AX_DI_ES MACRO name
    local done, jmp_table, fail, return, forme
    .errb <name>

    .DATA                                   ;; declare the jump table
jmp_table  dw   done                        ;; dl 0 is undefined
    IRP idx, <1,2,3,4,5,6,7,8>
    if idx le ip_&name&_dls
        IP_INIT_DL_JMP_TAB name, idx, write_access
    endif
    endm

    .CODE
    mov word ptr ip_&name&_data.ip_write_dst, AX            ;; save address
    mov word ptr ip_&name&_data.ip_write_dst+2, BX
    mov byte ptr ip_&name&_data.ip_write_proto, DL

    xor SI, SI
    mov DI, SI
    ROUTE_FIND_in_AX_BX_SI_DI_out_AX_BX_DX_const_CX_BP_ES name, forme, fail, fail
    mov byte ptr ip_&name&_data.ip_write_dl, DL
    mov word ptr ip_&name&_data.ip_write_gate, AX
    mov word ptr ip_&name&_data.ip_write_gate+2, BX

    xor DH, DH                              ;; set up jump to proper DL
    shl DX, 1
    mov DI, offset jmp_table
    add DI, DX
    jmp [DI]

    forme:
    fail:
        xor AX, AX
        dec AX
        jmp return

        ;; the above jump goes to one of the code fragments below
    IRP idx, <1,2,3,4,5,6,7,8>
    if idx le ip_&name&_dls
        IP_INIT_DL_LABEL name, idx, write_access
        IP_SAVE_SRC name, idx
        cmp CX, dl_ip_min_mtu           ;; enforce length restriction
        ja  fail
        DL_IP_W_ACCESS_in_CX_out_DI_ES_const_CX_BP idx, fail
        jmp done
    endif
    endm
        ;; the above code does NOT fall through
    done:
    mov word ptr ip_&name&_data.ip_write_off, DI
    mov word ptr ip_&name&_data.ip_write_seg, ES
    add DI, size ip
    xor AX, AX
    return:
ENDM

IP_SAVE_SRC MACRO name, dl
    mov AX, word ptr dl_ip_&dl&_ip
    mov word ptr ip_&name&_data.ip_write_src, AX
    mov AX, word ptr dl_ip_&dl&_ip+2
    mov word ptr ip_&name&_data.ip_write_src+2, AX
ENDM
ENDIF ; IP_REAL_DEFINE_NEEDED

;;*****************************************************************************
;; IP_SET_SRC_in_AX_BX_const_AX_BX_CX_DX_BP_SI_DI_ES name
;;      IP_SET_SRC sets the IP source address to the value contained in
;;      AX:BX (overrides the address set by IP_W_ACCESS).
;;
IP_SET_SRC_in_AX_BX_const_AX_BX_CX_DX_BP_SI_DI_ES MACRO name
    mov word ptr ip_&name&_data.ip_write_src, AX
    mov word ptr ip_&name&_data.ip_write_src+2, BX
ENDM

;;*****************************************************************************
;; IP_GET_SRC_out_AX_BX_const_CX_DX_BP_SI_DI_ES name
;;      IP_GET_SRC returns the IP source address in AX:BX.
;;
IP_GET_SRC_out_AX_BX_const_CX_DX_BP_SI_DI_ES MACRO name
    mov AX, word ptr ip_&name&_data.ip_write_src
    mov BX, word ptr ip_&name&_data.ip_write_src+2
ENDM

;;*****************************************************************************
;; IP_GET_DST_out_AX_BX_const_CX_DX_BP_SI_DI_ES name
;;      IP_GET_DST returns the IP destination address in AX:BX.
;;
IP_GET_DST_out_AX_BX_const_CX_DX_BP_SI_DI_ES MACRO name
    mov AX, word ptr ip_&name&_data.ip_write_dst
    mov BX, word ptr ip_&name&_data.ip_write_dst+2
ENDM


;;*****************************************************************************
;; IP_W_WRITE_in_CX name
;;      IP_W_WRITE tells the IP interface to send the PACKET that is been
;;      loaded into the buffer DI:ES.  The length of the packet is in CX
;;      note that this IP level does NOT support fragmentation, so CX better
;;      be less than the dl_ip_min_mtu
;;
IP_W_WRITE_in_CX MACRO name
    .errb <name>

    CALL ip_&name&_w_write
ENDM

;;*****************************************************************************
;;
;;      IP_REAL_W_WRITE_in_CX is the real provider of the W_WRITE service.
;;      it is identical in function to IP_W_WRITE.
;;
IFDEF IP_REAL_DEFINE_NEEDED
IP_REAL_W_WRITE_in_CX MACRO name
    local done, jmp_table
    .errb <name>

    .DATA                                   ;; declare the jump table
jmp_table  dw   done                        ;; dl 0 is undefined
    IRP idx, <1,2,3,4,5,6,7,8>
    if idx le ip_&name&_dls
        IP_INIT_DL_JMP_TAB name, idx, write_it
    endif
    endm

    .CODE
    les DI, dword ptr ip_&name&_data.ip_write_off
    mov AX, 0045H               ;; byte swapped length = 5 version = 4 tos = 0
    mov BX, AX
    stosw
    add CX, size ip
    mov AX, CX                  ;; the length
    xchg AL, AH
    add BX, AX
    stosw
    mov AX, word ptr ip_&name&_data.ip_write_id
    adc BX, AX
    stosw
    inc AX
    mov word ptr ip_&name&_data.ip_write_id, AX
    mov AX, 0
    stosw
    mov AL, 100                 ;; the time to live
    mov AH, byte ptr ip_&name&_data.ip_write_proto
    adc BX, AX
    stosw
    inc DI
    inc DI                      ;; skip checksum
    mov SI, offset ip_&name&_data.ip_write_src
    lodsw
    adc BX, AX
    stosw
    lodsw
    adc BX, AX
    stosw
    mov SI, offset ip_&name&_data.ip_write_dst
    lodsw
    adc BX, AX
    stosw
    lodsw
    adc BX, AX
    adc BX, 0
    stosw

    sub DI, 10
    not BX
    mov AX, BX
    stosw

        ;; set out the packet
    mov AX, word ptr ip_&name&_data.ip_write_gate
    mov BX, word ptr ip_&name&_data.ip_write_gate+2

    xor DH, DH                              ;; set up jump to proper DL
    mov DL, byte ptr ip_&name&_data.ip_write_dl
    shl DX, 1
    mov DI, offset jmp_table
    add DI, DX
    jmp [DI]

        ;; the above jump goes to one of the code fragments below
    IRP idx, <1,2,3,4,5,6,7,8>
    if idx le ip_&name&_dls
        IP_INIT_DL_LABEL name, idx, write_it
        DL_IP_W_WRITE_in_AX_BX_CX_const_BP idx
        jmp done
    endif
    endm
        ;; the above code does NOT fall through
    done:
ENDM
ENDIF ; IP_REAL_DEFINE_NEEDED


;;*****************************************************************************
;; IP_INIT_DL name, dl
;;      IP_INIT_DL initializes the data link interface 'dl'

IP_INIT_DL MACRO name, dl
    local around, not_silent, dont_drop, dont_split
    .errb <dl>

    jmp around
    ;;  This stuff can be compiled seperately
    ;   IP_DL_PACKET_in_BX_ES name, dl
    ;   DL_IP_R_RETURN dl
            ;; This does NOT fall through

    around:
    mov AX, DS          ;; add the route for each directly connected interface
    mov ES, AX
    xor CX, CX
    test word ptr dl_ip_&dl&_flags, IF_ROUTE_SILENT
    jz not_silent
    or CH, ROUTE_SILENT
not_silent:
    test word ptr dl_ip_&dl&_flags, IF_ROUTE_DROP
    jz dont_drop
    or CH, ROUTE_DROP
dont_drop:
    test word ptr dl_ip_&dl&_flags, IF_ROUTE_SPLIT
    jz dont_split
    or CH, ROUTE_SPLIT
dont_split:
    mov SI, offset dl_ip_&dl&_net
    mov DI, SI
    mov DX, offset dl_ip_&dl&_mask
    mov AX, word ptr dl_ip_&dl&_id
    ROUTE_ADD_in_AX_CX_DX_SI_DI_ES_const_DI_ES %ip_&name&_router

    DL_IP_R_READ dl, ip_&name&_dl_&dl&_read_start   ;; schedule the read
ENDM


;;*****************************************************************************
;; IP_DL_PACKET_in_BX_ES name, read_dl
;;      IP_DL_PACKET_in_BX_ES does the proessing of a packet that came from
;;      a data link interface BX:ES points to the begining of the IP packet.
;;      this is the routine that does the routing and if it for this node
;;      calls IP_PACKET_in_BX_CX_ES
;;
IFDEF IP_DL_PACKET_NEEDED
IP_DL_PACKET_in_BX_ES MACRO name, read_dl
    local forme, jmp_table, drop, ip_write_sav, ip_write_gate, ip_write_size
    local ip_write_sav_seg, fromme, src_is_me
    local drop_ttl, drop_route, broad_forme, redirect, continue_forme, ip_ok
    local src_ok, src_ok1, do_check, net_unreach
    local find_route, find_sroute
    .errb <read_dl>

    .DATA                                   ;; declare the jump table
jmp_table  dw   drop                        ;; dl 0 is undefined
    IRP idx, <1,2,3,4,5,6,7,8>
    if idx le ip_&name&_dls
        IP_INIT_DL_JMP_TAB name, idx, read_dl&_write_start
    endif
    endm

ip_write_size    DW  ?
ip_write_sav     DW  ?
ip_write_sav_seg DW  ?
ip_write_gate    DD  ?
src_is_me        DB  ?

    .CODE
    ip_&name&_dl_&read_dl&_read_start:
    mov ip_write_sav, BX
    mov BP, BX                                      ;; save BX

    mov DX, word ptr ES:[BX+ip_check]       ;; prepare for checksum calculation
    mov word ptr ES:[BX+ip_check], 0
    mov SI, BX
    IP_COMPUTE_CHECK_in_SI_ES_out_BX_const_DX_BP_DI_ES
    cmp DX, BX
    jne drop
    mov BX, BP
    mov word ptr ES:[BX+ip_check], DX       ;; restore checksum

    mov CX, word ptr ES:[BX+ip_length]      ;; make sure length reasonable
    xchg CH, CL                             ;; byte swap

    cmp CX, dl_ip_&read_dl&_mtu
    ja drop
    mov ip_write_size, CX

    mov AL, byte ptr ES:[BX+ip_dst]
    or AL, AL                               ;; check for invalid addresses
    jz drop_route
    cmp AL, 127                             ;; local loopback net
    je drop_route

        ;; source address check
    mov AX, word ptr ES:[BX+ip_src]
    mov BX, word ptr ES:[BX+ip_src+2]
    or AX, AX
    jnz do_check
    or BX, BX
    jz src_ok
  do_check:
    or AL, AL                               ;; check for invalid addresses
    jz drop_route
    cmp AL, 127                             ;; local loopback net
    je drop_route
    cmp AX, 0ffffh                          ;; local broadcast address
    jne find_sroute
    cmp BX, 0ffffh
    je drop_route
  find_sroute:
    mov SI, word ptr ES:[BP+ip_dst]
    mov DI, word ptr ES:[BP+ip_dst+2]
    ROUTE_FIND_in_AX_BX_SI_DI_out_AX_BX_DX_const_CX_BP_ES name, fromme, drop_route, drop_route
    test word ptr dl_ip_&read_dl&_flags, NO_REVERSE_CHECK
    jnz src_ok
    cmp DL, read_dl                         ;; would be routed to same dl?
    jne drop_route
    jmp src_ok
  fromme:
    mov BL, 1
    cmp byte ptr ES:[BP+ip_proto], UDP_PROTO ;; allow UDP from my device drivers
    je src_ok1
    jmp drop
  src_ok:
    xor BL, BL
  src_ok1:
    mov byte ptr src_is_me, BL
    mov BX, BP
    DL_IP_IS_BROADCAST_in_BX_ES_const_AX_BX_CX_DX_BP_DI_ES read_dl
    jnz broad_forme

    mov AX, word ptr ES:[BX+ip_dst]
    mov BX, word ptr ES:[BX+ip_dst+2]
    cmp AX, 0ffffh                          ;; local broadcast address
    jne find_route
    cmp BX, 0ffffh
    je drop_route
  find_route:
    mov SI, word ptr ES:[BP+ip_src]
    mov DI, word ptr ES:[BP+ip_src+2]
    ROUTE_FIND_in_AX_BX_SI_DI_out_AX_BX_DX_const_CX_BP_ES name, forme, drop_route, drop_route
    mov word ptr ip_write_gate, AX
    mov word ptr ip_write_gate+2, BX

    mov SI, BP                                      ;; restore pointer
    IP_DEC_TTL_in_SI_ES_const_BX_CX_DX_BP_SI_DI_ES drop_ttl

    xor DH, DH                              ;; set up jump to proper DL
    shl DX, 1
    mov DI, offset jmp_table
    add DI, DX

    jmp [DI]                                ;; jump to proper DL

        ;; the above jump goes to one of the code fragments below
    IRP idx, <1,2,3,4,5,6,7,8>
    if idx le ip_&name&_dls
        IP_INIT_DL_LABEL name, idx, read_dl&_write_start

        if idx eq read_dl
            mov word ptr ip_write_sav_seg, ES
        endif

        mov BP, word ptr ip_write_sav
        IP_DL_TEST_BROAD_in_BP_ES_const_CX_DX_BP_SI_DI_ES idx, drop
        IP_SEND_PACKET_in_BP_ES name, read_dl, idx, ip_write_gate

        if idx eq read_dl
            IP_DL_TEST_FLAGS idx, NO_REDIRECT
            jnz drop

            mov SI, word ptr ip_write_sav
            mov ES, word ptr ip_write_sav_seg

            mov AX, word ptr ip_write_gate
            mov BX, word ptr ip_write_gate+2
            jmp redirect
        else
            jmp drop
        endif
    endif
    endm
        ;; the above code does NOT fall through

    drop_route:
        mov SI, BP
        mov AX, word ptr ES:[SI+ip_src]
        mov BX, word ptr ES:[SI+ip_src+2]
        IP_COMP_NET_in_AX_BX_out_AX_BX_const_CX_DX_BP_SI_DI_ES
        push BX
        push AX
        mov AX, word ptr ES:[SI+ip_dst]
        mov BX, word ptr ES:[SI+ip_dst+2]
        IP_COMP_NET_in_AX_BX_out_AX_BX_const_CX_DX_BP_SI_DI_ES
        pop CX
        cmp AX, CX
        pop CX
        jne net_unreach
        cmp BX, CX
        jne net_unreach
        ICMP_ERROR_in_SI_ES %ip_&name&_icmp, ICMP_UNREACHABLE, ICMP_UNREACH_HOST, name
        jmp drop
    net_unreach:
        ICMP_ERROR_in_SI_ES %ip_&name&_icmp, ICMP_UNREACHABLE, ICMP_UNREACH_NET, name
        jmp drop
    redirect:
        ICMP_REDIRECT_in_AX_BX_SI_ES %ip_&name&_icmp, ICMP_REDIRECT_HOST, name
        jmp drop
    drop_ttl:
        ICMP_ERROR_in_SI_ES %ip_&name&_icmp, ICMP_TIME, ICMP_TIME_TTL, name
        jmp drop
    broad_forme:
        cmp byte ptr src_is_me, 0
        jne drop         ;; don't accept packets that are apparently from me
    IP_DL_ROUTE_BROADCAST_in_BX_ES name, read_dl
        mov ip_&name&_data.ip_broadcast, 1
        jmp continue_forme
    forme:
        cmp byte ptr src_is_me, 0
        jne drop         ;; don't accept packets that are apparently from me
        mov ip_&name&_data.ip_broadcast, 0
    continue_forme:
        mov BX, ip_write_sav
        mov CX, ip_write_size
        DL_IP_R_CONT_in_BX_CX_ES_const_BX_CX_DX_BP_SI_DI_ES read_dl, ip_ok
            mov SI, BX
            mov DI, offset ip_&name&_data.ip_packet
            mov DX, DS
            mov ES, DX
            mov DS, ip_write_sav_seg
            DL_IP_COPY_in_CX_SI_DI_ES_out_SI_DI_const_BX_BP_ES read_dl
            mov DX, ES
            mov DS, DX
            mov BX, offset ip_&name&_data.ip_packet
            mov CX, ip_write_size
        ip_ok:
        CALL ip_&name&_read_packet
    drop:
ENDM

IP_DL_ROUTE_BROADCAST_in_BX_ES MACRO name, read_dl
    local done

    mov DX, word ptr ES:[BX+ip_dst+2]
    cmp DX, word ptr dl_ip_&read_dl&_gbroad+2
    jne done
    mov AX, word ptr ES:[BX+ip_dst]
    cmp AX, word ptr dl_ip_&read_dl&_gbroad
    jne done
    IRP idx, <1,2,3,4,5,6,7,8>
    if idx le ip_&name&_dls
        if idx ne read_dl
        IP_DL_ROUTE_ONE_BROADCAST_in_BX_ES name, read_dl, idx
        endif
    endif
    endm
  done:
ENDM

IP_DL_ROUTE_ONE_BROADCAST_in_BX_ES MACRO name, read_dl, write_dl
    local do_global_broadcast, send_broadcast, done
    local ip_write_gate

    .DATA
  ip_write_gate    DD ?
    .CODE

    test word ptr dl_ip_&write_dl&_flags, ROUTE_BROADCASTS
    jz done
    mov DX, word ptr dl_ip_&write_dl&_gbroad+2  ; route broadcasts only
    cmp DX, word ptr dl_ip_&read_dl&_gbroad+2   ; between subnets of the
    jne done                                    ; same net
    mov AX, word ptr dl_ip_&write_dl&_gbroad
    cmp AX, word ptr dl_ip_&read_dl&_gbroad
    jne done
    test word ptr dl_ip_&write_dl&_flags, GLOBAL_BROADCAST
    jnz send_broadcast
        mov AX, word ptr dl_ip_&write_dl&_broad     ; Send to local broadcast
        mov DX, word ptr dl_ip_&write_dl&_broad+2   ;   address
    send_broadcast:
ifdef arp_&write_dl&_declared
    xchg BX, DX
    ARP_TAB_GET_FIXED_in_AX_BX_out_SI_const_AX_BX_CX_DX_BP_DI_ES %arp_&write_dl&_arptab
    xchg DX, BX
    or SI, SI
    jz done                ; No ARP entry for broadcast address
endif
    mov BP, word ptr ES:[BX+ip_dst]    ; Save broadcast address received
    push BP
    mov BP, word ptr ES:[BX+ip_dst+2]
    push BP
    mov word ptr ES:[BX+ip_dst], AX    ; Set desired broadcast address
    mov word ptr ES:[BX+ip_dst+2], DX
    mov BP, BX
    mov word ptr ip_write_gate, AX
    mov word ptr ip_write_gate+2, DX
    push BX
    push ES
    IP_SEND_PACKET_in_BP_ES name, read_dl, write_dl, ip_write_gate
    pop ES
    pop BX
    pop BP                ; Restore broadcast address received
    mov word ptr ES:[BX+ip_dst+2], BP
    pop BP
    mov word ptr ES:[BX+ip_dst], BP
  done:
ENDM

;; this macro tests if the flag bit 'mybit' of the DL_IP 'name' is set
IP_DL_TEST_FLAGS MACRO name, mybit
    test dl_ip_&name&_flags, mybit
ENDM

;; This macro tests if the packet pointed to by BP:ES should be dropped
;; because it is a broadcast
IP_DL_TEST_BROAD_in_BP_ES_const_CX_DX_BP_SI_DI_ES MACRO name, drop
    local forward, test_flag, test_global

    mov AX, word ptr ES:[BP+ip_dst]
    mov BX, word ptr ES:[BP+ip_dst+2]
    cmp BX, word ptr dl_ip_&name&_broad+2
    jne test_global
    cmp AX, word ptr dl_ip_&name&_broad
    je test_flag
  test_global:
    cmp BX, word ptr dl_ip_&name&_gbroad+2
    jne forward
    cmp AX, word ptr dl_ip_&name&_gbroad
    jne forward
  test_flag:
    test word ptr dl_ip_&name&_flags, NO_DIR_BROAD
    jnz drop
  forward:
ENDM
ENDIF ; IP_DL_PACKET_NEEDED

;;*****************************************************************************
;;  IP_INIT_DL_LABEL generates a code lable for use in a jump table for
;;  'name', 'dl'.  'suffix' is a unique suffix
;;
IP_INIT_DL_LABEL MACRO name, dl, suffix
    ip_&name&_dl_&dl&_&suffix:
ENDM

;;*****************************************************************************
;;  IP_INIT_DL_JMP_TAB generates the table entry for the entry 'name', 'dl'
;;  'suffix' is a unique suffix.
;;  This is meant for use in a .DATA section
;;
IP_INIT_DL_JMP_TAB MACRO name, dl, suffix
    dw ip_&name&_dl_&dl&_&suffix
ENDM


;;****************************************************************************
;; IP_SEND_PACKET sends the packet pointed to by BP:ES of from the
;; DL 'read_dl' to the dl 'write_dl'.  'gate' is an address that contains
;; the last two bytes of the IP address.  This is the routine that handles
;; IP fragmentation
;;
IFDEF IP_DL_PACKET_NEEDED
IP_SEND_PACKET_in_BP_ES MACRO name, read_dl, write_dl, gate
    local done, frag_loop, size_ok, fragment, ip_head_len, ip_save_seg, skip

    .DATA
    ip_head_len     DW ?
    ip_save_seg     DW ?

    .CODE
    mov word ptr ip_save_seg, ES
    mov CX, ES:[BP+ip_length]
    xchg CH, CL
    if dl_ip_&read_dl&_mtu gt dl_ip_&write_dl&_mtu  ;;is fragmenting EVER needed
    cmp CX, dl_ip_&write_dl&_mtu
    ja fragment
    endif
        DL_IP_W_ACCESS_in_CX_out_DI_ES_const_CX_BP write_dl, done
        mov SI, BP                      ;; restore SI
        mov BX, CX                      ;; save CX
        push DS
        mov DS, word ptr ip_save_seg
        DL_IP_COPY_in_CX_SI_DI_ES_out_SI_DI_const_BX_BP_ES read_dl
        pop DS
        mov CX, BX                      ;; restore CX

        mov AX, word ptr gate
    mov BX, word ptr gate+2
        DL_IP_W_WRITE_in_AX_BX_CX_const_BP write_dl

    if dl_ip_&read_dl&_mtu gt dl_ip_&write_dl&_mtu  ;;is fragmenting EVER needed
        jmp done
    fragment:
        test byte ptr ES:[BP+ip_frag], SWAPPED_IP_DONT_FRAG   ;; OK to fragment?
        jz skip
        mov SI, BP
        ICMP_ERROR_in_SI_ES %ip_&name&_icmp, ICMP_UNREACHABLE, ICMP_CANT_FRAGMENT, name
        jmp done

    skip:
            ;; compute the header size
        xor CX, CX          ;; make CX hold the size of the IP header
        mov CL, byte ptr ES:[BP+ip_ver_size]
        and CL, 0FH
        shl CL, 1
        shl CL, 1
        mov word ptr ip_head_len, CX

        mov AX, DS          ;; copy the header
        mov ES, AX
        mov SI, BP
        mov DI, offset ip_&name&_data.ip_header
        push DS
        mov DS, word ptr ip_save_seg
        DL_IP_COPY_in_CX_SI_DI_ES_out_SI_DI_const_BX_BP_ES read_dl
        pop DS
        mov BP, SI          ;; save SI

            ;; fix checksum so it is correct when ip_frag = ip_len = 0
        mov AX, word ptr ip_&name&_data.ip_header.ip_check
        add AX, word ptr ip_&name&_data.ip_header.ip_frag
        adc AX, word ptr ip_&name&_data.ip_header.ip_length
        adc AX, 0
        mov word ptr ip_&name&_data.ip_header.ip_check, AX

        frag_loop:
            mov CX, dl_ip_&write_dl&_mtu            ;; ask for biggest buffer
            DL_IP_W_ACCESS_in_CX_out_DI_ES_const_CX_BP write_dl, done
            mov DX, word ptr ip_head_len        ;; copy the header
            mov CX, DX
            mov SI, offset ip_&name&_data.ip_header
            shr CX, 1
            rep
            movsw
            sub DI, DX              ;; make DI point to begining of the packet

            mov AX, word ptr ES:[DI+ip_frag]
            xchg AH, AL
            mov CX, word ptr ES:[DI+ip_length]
            xchg CH, CL
            cmp CX, dl_ip_&write_dl&_mtu                    ;; can we send it
            jbe size_ok
                mov CX, dl_ip_&write_dl&_mtu
                sub CX, DX              ;; subtract the IP header length
                and CX, 0FFF8H          ;; make multiple of 8
                add CX, DX              ;; add the IP header length
                or AX,  IP_MORE_FRAG    ;; indicate not the last
            size_ok:
            xchg CH, CL
            mov word ptr ES:[DI+ip_length], CX
            xchg AH, AL
            mov word ptr ES:[DI+ip_frag], AX

            mov BX, word ptr ES:[DI+ip_check]       ;; fix up checksum
            sub BX, CX
            sbb BX, AX
            sbb BX, 0
            mov word ptr ES:[DI+ip_check], BX

                ;; set up stuff for next round
            xchg CH, CL
            sub CX, DX                  ;; subtract the IP header length
            mov BX, CX
            shr BX, 1
            shr BX, 1
            shr BX, 1
            mov AX, word ptr ip_&name&_data.ip_header.ip_frag
            xchg AH, AL
            add AX, BX
            xchg AH, AL
            mov word ptr ip_&name&_data.ip_header.ip_frag, AX

            mov BX, word ptr ip_&name&_data.ip_header.ip_length
            xchg BH, BL
            sub BX, CX
            xchg BH, BL
            mov word ptr ip_&name&_data.ip_header.ip_length, BX

            mov SI, BP                      ;; restore SI
            add DI, DX                      ;; restore DI
            mov BX, CX
            add BX, DX                      ;; BX holds total Lenght
            push DS
            mov DS, word ptr ip_save_seg
            DL_IP_COPY_in_CX_SI_DI_ES_out_SI_DI_const_BX_BP_ES read_dl
            pop DS
            mov BP, SI                      ;; save SI

            mov AX, word ptr gate
            mov CX, BX
        mov BX, word ptr gate+2
            DL_IP_W_WRITE_in_AX_BX_CX_const_BP write_dl

            mov BX, word ptr ip_&name&_data.ip_header.ip_length
            xchg BH, BL
            cmp BX, word ptr ip_head_len
        ja frag_loop
    endif
    done:
ENDM


;;******************************************************************************
;; IP_DEC_TTL_in_BX_ES
;;      IP_DEC_TTL  decrements the TTL of the IP packet pointed to by SI:ES
;;      and jumps to 'drop' if the TTL has expired.
;;
IP_DEC_TTL_in_SI_ES_const_BX_CX_DX_BP_SI_DI_ES MACRO drop
    mov AL, byte ptr ES:[SI+ip_ttl]             ;; decrement ttl
    sub AL, 01                                  ;; can't use dec (need carry)
    jbe drop
    mov byte ptr ES:[SI+ip_ttl], AL
    mov AX, word ptr ES:[SI+ip_check]           ;; fix up checksum
    add AX, 1                                   ;; add 1 in 1's complement
    adc AX, 0
    mov word ptr ES:[SI+ip_check], AX
ENDM
ENDIF ; IP_DL_PACKET_NEEDED


;;******************************************************************************
;;    IP_COMP_NET
;;      IP_COMP_NET takes an IP address in AX,BX and computes the network
;;      part of the IP address based on the class of the IP address and
;;      returns it in AX,BX.
;;
IP_COMP_NET_in_AX_BX_out_AX_BX_const_CX_DX_BP_SI_DI_ES MACRO
    local class_A, class_B, class_C

    test AL, 80h        ;; normal IP network interpretation
    jz class_A
    test AL, 40h
    jz class_B
    jmp class_C

    class_A:
        xor AH, AH
    class_B:
        xor BL, BL
    class_C:
        xor BH, BH
ENDM


;;*****************************************************************************
;; IP_PACKET_in_BX_CX_ES name
;;      IP_PACKET_in_BX_CX_ES does all the proessing of a packet that is
;;      destined for this node.  BX:ES points to the begining of the IP packet.
;;      CX holds the length of the packet.
;;      Basicly this routine just dispatches it to the proper READ routine
;;
IFDEF IP_REAL_DEFINE_NEEDED
IP_PACKET_in_BX_CX_ES MACRO name
    local drop
    .errb <name>

    test word ptr ES:[BX+ip_frag], SWAPPED_IP_IS_FRAG   ;; if fragmented
    jnz drop

    xor AH, AH
    mov AL, byte ptr ES:[BX+ip_proto]                   ;; load protocol
    mov word ptr ip_&name&_data.ip_read_head, BX        ;; save header pointer
    xor DH, DH                              ;; compute the size of the header
    mov DL, byte ptr ES:[BX+ip_ver_size]
    and DL, 0FH
    shl DX, 1
    shl DX, 1
    sub CX, DX
    add BX, DX

    mov DX, AX                              ;; jump to proper routine
    and DL, 1FH
    cmp DL, AL
    jne ip_&name&_prot_unreach
    shl DX, 1
    mov SI, offset ip_&name&_data.ip_read_jmp
    add SI, DX
    jmp [SI]                                ;; note this is NOT a call,
                                            ;; so when the code returns
                                            ;; it will return to the caller
                                            ;; of this routine

    drop:
ENDM
ENDIF ; IP_REAL_DEFINE_NEEDED


;;*****************************************************************************
IP_COMPUTE_CHECK_in_SI_ES_out_BX_const_DX_BP_DI_ES MACRO
    local check_loop

    xor CX, CX              ;; make CX hold the size of the IP header
    mov CL, byte ptr ES:[SI+ip_ver_size]
    and CL, 0FH
    shl CX, 1
    xor BX, BX              ;; also clears carry
    check_loop:
        seges
        lodsw
        adc BX, AX
    loop check_loop
    adc BX, 0               ;; add in the last carry if any
    not BX
ENDM


;;*****************************************************************************
;; IP_ASCII_in_SI_DI_ES_out_DI converts the IP address stored at SI:DS
;; to ASCII dot notation in the buffer ENDING at DI:ES.  DI:ES returns the
;; begining of the string generated.
;;
IP_ASCII_in_SI_DI_ES_out_DI_const_BX_BP_ES MACRO
    local ip_loop, ip_loop_done

    std                                     ;; count down
    mov CX, 4
    add SI, 3
    dec DI
    ip_loop:
        lodsb
        TO_ASCII_in_AL_DI_ES_out_DI_const_BX_CX_BP_SI_ES
        dec CX
        jz ip_loop_done
        mov AL, '.'
        stosb
    jmp ip_loop
    ip_loop_done:
    inc DI
    cld                                     ;; count up again
ENDM


;;*****************************************************************************
;; TO_ASCII converts the number in AL to ascii (decimal) and puts the resulting
;; string in the buffer whose END is pointed to by DI:ES.  DI points to the
;; BEGINING of the string when it is done.  THIS ROUTINE ASSUMES THE DIRECTION
;; FLAG IS COUNTING DOWN
;;
TO_ASCII_in_AL_DI_ES_out_DI_const_BX_CX_BP_SI_ES MACRO
    local loop_write

    mov DL, 10
    loop_write:            ;; write in the number
        xor AH, AH
        idiv DL            ;; AH = AL % 10      AL = AL / 10
        xchg AL, AH
        add AL, 48          ;; add ascii '0'
        stosb
        mov AL, AH
        and AL, AL
    jnz loop_write
ENDM