ip.c

Snmp（简单网管协议）软件包。

					 + ipstat.ips_toosmall
					 + ipstat.ips_badhlen
					 + ipstat.ips_badlen;
				return (u_char *) &long_return;
	case IPINADDRERRORS:	long_return = ipstat.ips_cantforward;
			        return (u_char *) &long_return;
	case IPFORWDATAGRAMS:	long_return = ipstat.ips_forward;
			        return (u_char *) &long_return;
	case IPINUNKNOWNPROTOS:
#if STRUCT_IPSTAT_HAS_IPS_NOPROTO
				long_return = ipstat.ips_noproto;
				return (u_char *) &long_return;
#else
				return NULL;
#endif
	case IPINDISCARDS:
#if STRUCT_IPSTAT_HAS_IPS_FRAGDROPPED
				long_return = ipstat.ips_fragdropped;	/* ?? */
				return (u_char *) &long_return;
#else
				return NULL;
#endif
	case IPINDELIVERS:
#if STRUCT_IPSTAT_HAS_IPS_DELIVERED
				long_return = ipstat.ips_delivered;
			        return (u_char *) &long_return;
#else
				return NULL;
#endif
	case IPOUTREQUESTS:
#if STRUCT_IPSTAT_HAS_IPS_LOCALOUT
				long_return = ipstat.ips_localout;
				return (u_char *) &long_return;
#else
				return NULL;
#endif
	case IPOUTDISCARDS:
#if STRUCT_IPSTAT_HAS_IPS_ODROPPED
				long_return = ipstat.ips_odropped;
				return (u_char *) &long_return;
#else
				return NULL;
#endif
	case IPOUTNOROUTES:
            /* XXX: how to calculate this (counts dropped routes, not packets)?
               ipstat.ips_cantforward isn't right, as it counts packets.
               ipstat.ips_noroute is also incorrect.
            */
				return NULL;
	case IPREASMTIMEOUT:
				long_return = IPFRAGTTL;
			        return (u_char *) &long_return;
	case IPREASMREQDS:	long_return = ipstat.ips_fragments;
			        return (u_char *) &long_return;
	case IPREASMOKS:
#if STRUCT_IPSTAT_HAS_IPS_REASSEMBLED
				long_return = ipstat.ips_reassembled;
				return (u_char *) &long_return;
#else
				return NULL;
#endif
	case IPREASMFAILS:	long_return = ipstat.ips_fragdropped
					 + ipstat.ips_fragtimeout;
				return (u_char *) &long_return;
	case IPFRAGOKS:			/* XXX */
				long_return = ipstat.ips_fragments
				      - (ipstat.ips_fragdropped + ipstat.ips_fragtimeout);
				return (u_char *) &long_return;
	case IPFRAGFAILS:
#if STRUCT_IPSTAT_HAS_IPS_CANTFRAG
				long_return = ipstat.ips_cantfrag;
				return (u_char *) &long_return;
#else
				return NULL;
#endif
	case IPFRAGCREATES:
#if STRUCT_IPSTAT_HAS_IPS_OFRAGMENTS
				long_return = ipstat.ips_ofragments;
				return (u_char *) &long_return;
#else
				return NULL;
#endif
	case IPROUTEDISCARDS:
#if STRUCT_IPSTAT_HAS_IPS_NOROUTE
				long_return = ipstat.ips_noroute;
				return (u_char *) &long_return;
#else
				return NULL;
#endif

#endif		/* USE_TRADITIONAL_IPSTAT */
#ifdef WIN32
	case IPFORWARDING:	
    *write_method = writeIpStats;
    ipForwarding = ipstat.dwForwarding;
    return (u_char *) &ipstat.dwForwarding;
	case IPDEFAULTTTL:	
    *write_method = writeIpStats;
    ipTTL = ipstat.dwDefaultTTL;
    return (u_char *) &ipstat.dwDefaultTTL;
       case IPINRECEIVES:      return (u_char *) &ipstat.dwInReceives;
       case IPINHDRERRORS:     return (u_char *) &ipstat.dwInHdrErrors;
       case IPINADDRERRORS:    return (u_char *) &ipstat.dwInAddrErrors;
       case IPFORWDATAGRAMS:   return (u_char *) &ipstat.dwForwDatagrams;
       case IPINUNKNOWNPROTOS: return (u_char *) &ipstat.dwInUnknownProtos;
       case IPINDISCARDS:      return (u_char *) &ipstat.dwInDiscards;
       case IPINDELIVERS:      return (u_char *) &ipstat.dwInDelivers;
       case IPOUTREQUESTS:     return (u_char *) &ipstat.dwOutRequests;
       case IPOUTDISCARDS:     return (u_char *) &ipstat.dwOutDiscards;
       case IPOUTNOROUTES:     return (u_char *) &ipstat.dwOutNoRoutes;
       case IPREASMTIMEOUT:    return (u_char *) &ipstat.dwReasmTimeout;
       case IPREASMREQDS:      return (u_char *) &ipstat.dwReasmReqds;
       case IPREASMOKS:        return (u_char *) &ipstat.dwReasmOks;
       case IPREASMFAILS:      return (u_char *) &ipstat.dwReasmFails;
       case IPFRAGOKS:         return (u_char *) &ipstat.dwFragOks;
       case IPFRAGFAILS:       return (u_char *) &ipstat.dwFragFails;
       case IPFRAGCREATES:     return (u_char *) &ipstat.dwFragCreates;
       case IPROUTEDISCARDS:   return (u_char *) &ipstat.dwRoutingDiscards;
#endif /* WIN32 */

	default:
	    DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_ip\n", vp->magic));
    }
    return NULL;

#ifdef HAVE_SYS_TCPIPSTATS_H
#undef	ipstat
#endif
}



	/*********************
	 *
	 *  Internal implementation functions
	 *
	 *********************/

long
read_ip_stat( IP_STAT_STRUCTURE *ipstat, int magic )
{
   long ret_value;
#if (defined(CAN_USE_SYSCTL) && defined(IPCTL_STATS))
   int i;
#endif
#if !(defined (linux) || defined(solaris2))
   static int ttl, forward;
#endif

#if ((defined(HAVE_SYS_SYSCTL_H) && defined(CTL_NET)) ||	\
     (defined(CAN_USE_SYSCTL) && defined(IPCTL_STATS)))
   static int sname[4] = { CTL_NET, PF_INET, IPPROTO_IP, 0 };
   size_t len;
#endif

    if (  ip_stats_cache_marker &&
	(!atime_ready( ip_stats_cache_marker, IP_STATS_CACHE_TIMEOUT*1000 )))
#if !(defined(linux) || defined(solaris2))
	return (( magic == IPFORWARDING ? forward :
		( magic == IPDEFAULTTTL ? ttl     : 0 )));
#else
	return 0;
#endif

    if (ip_stats_cache_marker )
	atime_setMarker( ip_stats_cache_marker );
    else
	ip_stats_cache_marker = atime_newMarker();


#ifdef linux
   ret_value = linux_read_ip_stat(ipstat);
#endif

#ifdef solaris2
    ret_value = getMibstat(MIB_IP, ipstat, sizeof(mib2_ip_t), GET_FIRST, &Get_everything, NULL);
#endif

#ifdef WIN32
    ret_value = GetIpStatistics(ipstat);
#endif

#if !(defined(linux) || defined(solaris2) || defined(WIN32))
    if ( magic == IPFORWARDING ) {

#if defined(CAN_USE_SYSCTL) && defined(IPCTL_STATS)
	len = sizeof i;
	sname[3] = IPCTL_FORWARDING;
	if (sysctl(sname, 4, &i, &len, 0, 0) < 0)
	    forward = -1;
	else
	    forward = (i ? 1	/* GATEWAY */
			 : 2	/* HOST    */  );
#else
	if (!auto_nlist(IP_FORWARDING_SYMBOL, (char *) &ret_value, sizeof(ret_value)))
	    forward = -1;
	else
	    forward = (ret_value ? 1	/* GATEWAY */
			         : 2	/* HOST    */  );
#endif
	if ( forward == -1 ) {
	    free( ip_stats_cache_marker );
	    ip_stats_cache_marker = NULL;
	}
	return forward;
    }

    if ( magic == IPDEFAULTTTL ) {

#if (defined(CAN_USE_SYSCTL) && defined(IPCTL_STATS))
	len = sizeof i;
	sname[3] = IPCTL_DEFTTL;
	if (sysctl(sname, 4, &i, &len, 0, 0) < 0)
	    ttl = -1;
	else
	    ttl = i;
#else
	if (!auto_nlist(TCP_TTL_SYMBOL, (char *) &ret_value, sizeof(ret_value)))
	    ttl = -1;
	else
	    ttl = ret_value;
#endif
	if ( ttl == -1 ) {
	    free( ip_stats_cache_marker );
	    ip_stats_cache_marker = NULL;
	}
	return ttl;
    }


#ifdef HAVE_SYS_TCPIPSTATS_H
    ret_value = sysmp (MP_SAGET, MPSA_TCPIPSTATS, ipstat, sizeof *ipstat);
#endif

#if (defined(CAN_USE_SYSCTL) && defined(IPCTL_STATS))
    len = sizeof *ipstat;
    sname[3] = IPCTL_STATS;
    ret_value = sysctl(sname, 4, ipstat, &len, 0, 0);
#endif
#ifdef IPSTAT_SYMBOL
    if (auto_nlist(IPSTAT_SYMBOL, (char *)ipstat, sizeof (*ipstat)))
	ret_value = 0;
#endif
#endif /* !(defined(linux) || defined(solaris2)) */

    if ( ret_value == -1 ) {
	free( ip_stats_cache_marker );
	ip_stats_cache_marker = NULL;
    }
    return ret_value;
}

#ifdef WIN32
int
writeIpStats(int action,	     
	    u_char *var_val,
	    u_char var_val_type,
	    size_t var_val_len,
	    u_char *statP,
	    oid *name,
	    size_t name_len)
{
    long *buf, *oldbuf;
    MIB_IPSTATS ipStats;
    int var;
    int retval = SNMP_ERR_NOERROR;
   /* #define for ip scalar objects are 1 less than corresponding sub-id in MIB
    * i.e. IPFORWARDING defined as 0, but ipForwarding registered as 1
    */
  var = name[7] - 1;
    switch(var){
      case IPFORWARDING:
        buf    = &ipForwarding;
        oldbuf = &oldipForwarding;
        break;
      case IPDEFAULTTTL:
        buf    = &ipTTL;
        oldbuf = &oldipTTL;
        break;
      default:
	      return SNMP_ERR_NOTWRITABLE;
    }

    switch ( action ) {
	case RESERVE1:		/* Check values for acceptability */
	    if (var_val_type != ASN_INTEGER){
                snmp_log(LOG_ERR, "not integer\n");
		     return SNMP_ERR_WRONGTYPE;
	    }
	    if (var_val_len > sizeof(int)){
                snmp_log(LOG_ERR, "bad length\n");
		     return SNMP_ERR_WRONGLENGTH;
	    }
	    switch(var){
      case IPFORWARDING:
        if(((int)*var_val < 1) || ((int)*var_val > 2)){
          snmp_log(LOG_ERR, "not supported ip forwarding : %d\n", *var_val);
		      return SNMP_ERR_WRONGVALUE;
        }
          break;
      case IPDEFAULTTTL:
        if((int)*var_val < 0){
          snmp_log(LOG_ERR, "not supported ip Default : %d\n", (int)*var_val);
		      return SNMP_ERR_WRONGVALUE;
        }
      }
	    break;

	case RESERVE2:		/* Allocate memory and similar resources */
      break;

	case ACTION:		
		/* Save the old value, in case of UNDO */
	    
      *oldbuf  = *buf;
      *buf = (int)*var_val;
	    break;

	case UNDO:		/* Reverse the SET action and free resources */   
	    *buf = *oldbuf;
	    break;

	case COMMIT:		/* Confirm the SET, performing any irreversible actions,
					and free resources */
    switch(var){
      case IPFORWARDING:
        /* Currently windows supports only ON->OFF */
        ipStats.dwForwarding = *buf;
        ipStats.dwDefaultTTL = MIB_USE_CURRENT_TTL;
        if(SetIpStatistics(&ipStats) != NO_ERROR){
          retval = SNMP_ERR_COMMITFAILED;
          snmp_log(LOG_ERR,  "Can't set ipForwarding, supports only enable->disable \n");
        }   
        break;
      case IPDEFAULTTTL:
        if( SetIpTTL((UINT)*buf) != NO_ERROR){
          retval = SNMP_ERR_COMMITFAILED;
          snmp_log(LOG_ERR,  "Can't set ipDefaultTTL\n");
        }   
        break;
      }
      
	case FREE:		/* Free any resources allocated */
    	break;
    }
    return retval;
} /* end of writeIpStats */
#endif /* WIN32 */