pgpnetprefsfirewallrule.c

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

	kPGPnetIPProtocol_pgm,
	kPGPnetIPProtocol_l2tp,
	kPGPnetIPProtocol_ddx,
	kPGPnetIPProtocol_iatp,
	kPGPnetIPProtocol_stp,
	kPGPnetIPProtocol_srp,
	kPGPnetIPProtocol_uti,
	kPGPnetIPProtocol_smp,
	kPGPnetIPProtocol_sm,
	kPGPnetIPProtocol_ptp,
	kPGPnetIPProtocol_fire,
	kPGPnetIPProtocol_crtp,
	kPGPnetIPProtocol_crudp,
	kPGPnetIPProtocol_sscopmce,
	kPGPnetIPProtocol_iplt,
	kPGPnetIPProtocol_sps,
	kPGPnetIPProtocol_pipe,
	kPGPnetIPProtocol_sctp,	
	kPGPnetIPProtocol_fc,
	kPGPnetIPProtocol_rsvp_e2e_ignore,
};
const PGPInt32 kPGPNumIPProtocols	=
	( sizeof( kIPProtocolStringList ) / sizeof( kIPProtocolStringList[ 0 ] ) );

PGPUInt16 kTCPServiceStringList[] =
{
	kPGPnetTCPService_tcpmux,
	kPGPnetTCPService_echo,
	kPGPnetTCPService_discard,
	kPGPnetTCPService_systat,
	kPGPnetTCPService_daytime,
	kPGPnetTCPService_netstat,
	kPGPnetTCPService_qotd,
	kPGPnetTCPService_msp,
	kPGPnetTCPService_chargen,
	kPGPnetTCPService_ftpdata,
	kPGPnetTCPService_ftp,
	kPGPnetTCPService_ssh,
	kPGPnetTCPService_telnet,
	kPGPnetTCPService_smtp,
	kPGPnetTCPService_time,
	kPGPnetTCPService_rlp,
	kPGPnetTCPService_nameserver,
	kPGPnetTCPService_whois,
	kPGPnetTCPService_remailck,
	kPGPnetTCPService_dns,
	kPGPnetTCPService_mtp,
	kPGPnetTCPService_bootps,
	kPGPnetTCPService_bootpc,
	kPGPnetTCPService_tftp,
	kPGPnetTCPService_gopher,
	kPGPnetTCPService_rje,
	kPGPnetTCPService_finger,
	kPGPnetTCPService_http,
	kPGPnetTCPService_link,
	kPGPnetTCPService_kerberos,
	kPGPnetTCPService_supdup,
	kPGPnetTCPService_linuxconf,
	kPGPnetTCPService_hostnames,
	kPGPnetTCPService_iso_tsap,
	kPGPnetTCPService_csnet_ns,
	kPGPnetTCPService_poppassd,
	kPGPnetTCPService_rtelnet,
	kPGPnetTCPService_pop2,
	kPGPnetTCPService_pop3,
	kPGPnetTCPService_sunrpc,
	kPGPnetTCPService_auth,
	kPGPnetTCPService_sftp,
	kPGPnetTCPService_uucppath,
	kPGPnetTCPService_nntp,
	kPGPnetTCPService_ntp,
	kPGPnetTCPService_netbios_ns,
	kPGPnetTCPService_netbios_dgm,
	kPGPnetTCPService_netbios_ssn,
	kPGPnetTCPService_imap2,
	kPGPnetTCPService_snmp,
	kPGPnetTCPService_snmp_trap,
	kPGPnetTCPService_cmip_man,
	kPGPnetTCPService_cmip_agent,
	kPGPnetTCPService_xdmcp,
	kPGPnetTCPService_nextstep,
	kPGPnetTCPService_bgp,
	kPGPnetTCPService_prospero,
	kPGPnetTCPService_irc,
	kPGPnetTCPService_smux,
	kPGPnetTCPService_at_rtmp,
	kPGPnetTCPService_at_nbp,
	kPGPnetTCPService_at_echo,
	kPGPnetTCPService_at_zis,
	kPGPnetTCPService_qmtp,
	kPGPnetTCPService_z3950,
	kPGPnetTCPService_ipx,
	kPGPnetTCPService_imap3,
	kPGPnetTCPService_rpc2portmap,
	kPGPnetTCPService_codaauth2,
	kPGPnetTCPService_ulistserv,
	kPGPnetTCPService_ldap,
	kPGPnetTCPService_https,
	kPGPnetTCPService_snpp,
	kPGPnetTCPService_ssmtp,
	kPGPnetTCPService_saft,
	kPGPnetTCPService_ike,
	kPGPnetTCPService_exec,
	kPGPnetTCPService_login,
	kPGPnetTCPService_shell,
	kPGPnetTCPService_printer,
	kPGPnetTCPService_talk,
	kPGPnetTCPService_ntalk,
	kPGPnetTCPService_route,
	kPGPnetTCPService_timed,
	kPGPnetTCPService_tempo,
	kPGPnetTCPService_courier,
	kPGPnetTCPService_conference,
	kPGPnetTCPService_netnews,
	kPGPnetTCPService_netwall,
	kPGPnetTCPService_uucp,
	kPGPnetTCPService_afpovertcp,
	kPGPnetTCPService_klogin,
	kPGPnetTCPService_kshell,
	kPGPnetTCPService_remotefs,
	kPGPnetTCPService_snews,
	kPGPnetTCPService_sldap,
	kPGPnetTCPService_kerberos_adm,
	kPGPnetTCPService_webster,
	kPGPnetTCPService_radius,
	kPGPnetTCPService_radacct,
	kPGPnetTCPService_cvspserver,
	kPGPnetTCPService_kerberos4,
	kPGPnetTCPService_kerberosm,
	kPGPnetTCPService_passwd_srv,
	kPGPnetTCPService_krb_prop,
	kPGPnetTCPService_krbupdate,
	kPGPnetTCPService_kpasswd,
	kPGPnetTCPService_simap,
	kPGPnetTCPService_spop3,
	kPGPnetTCPService_socks,
	kPGPnetTCPService_kpop,
	kPGPnetTCPService_mysql,
	kPGPnetTCPService_ircd,
	kPGPnetTCPService_rtsp_low,
	kPGPnetTCPService_rtsp_high,
	kPGPnetTCPService_webcache,
	kPGPnetTCPService_tproxy,
	kPGPnetTCPService_pgpskep,
	kPGPnetTCPService_girlfriend,
	kPGPnetTCPService_backorifice2k
};
const PGPInt32 kPGPNumTCPServices	=
	( sizeof( kTCPServiceStringList ) / sizeof( kTCPServiceStringList[ 0 ] ) );

PGPUInt8 kICMPTypeStringList[] =
{
	kPGPnetICMPType_EchoReply,
	kPGPnetICMPType_DestUnreachable,
	kPGPnetICMPType_SourceQuench,
	kPGPnetICMPType_Redirect,
	kPGPnetICMPType_EchoRequest,
	kPGPnetICMPType_RouterAdvertisement,
	kPGPnetICMPType_RouterSolicitation,
	kPGPnetICMPType_TimeExceeded,
	kPGPnetICMPType_ParameterProblem,
	kPGPnetICMPType_TimestampRequest,
	kPGPnetICMPType_TimestampReply,
	kPGPnetICMPType_InfoRequest,
	kPGPnetICMPType_InfoReply,
	kPGPnetICMPType_AddressMaskReq,
	kPGPnetICMPType_AddressmaskRep
};
const PGPInt32 kPGPNumICMPTypes =
	( sizeof( kICMPTypeStringList ) / sizeof( kICMPTypeStringList[ 0 ] ) );


	
	PGPError 
PGPGetIPProtocolString(
	PGPUInt16	uProtocol,
	PGPSize		sizeString,
	char *		pszString )
{
	PGPUInt32			idx;
	const TextEntry *	pentry;
	char				temp[ 256 ];
	char const *		psz	= NULL;
	PGPSize				len	= 0;
	PGPBoolean			bBufferBigEnough	= FALSE;
	PGPError			err					= kPGPError_NoErr;

	PGPValidateParam( sizeString >= 1 );
	PGPValidatePtr( pszString );
	*pszString	= '\0';
	
	for( idx = 0; idx < kPGP_NumIPProtocolEntries; ++idx )
	{
		pentry	= &sIPProtocols[ idx ];
		if ( pentry->number == uProtocol )
		{
			psz	= pentry->string;
			break;
		}
	}
	
	if ( IsNull( psz ) )
	{
		err = kPGPError_ItemNotFound;

		/* Produce something for missing services */
		sprintf( temp, "%ld", (long)uProtocol );
		psz	= temp;
	}
	
	len	= strlen( psz );
	bBufferBigEnough = ( len + 1 <= sizeString );
	if ( bBufferBigEnough )
	{
		strcpy( pszString, psz );
	}
	else
	{
		pgpCopyMemory( psz, pszString, sizeString - 1 );
		pszString[ sizeString - 1 ]	= '\0';
	}
	
	return( bBufferBigEnough ? err : kPGPError_BufferTooSmall );
}


	PGPError 
PGPGetTCPServiceString(
	PGPUInt16	uService,
	PGPSize		sizeString,
	char *		pszString )
{
	PGPUInt32			idx;
	const TextEntry *	pentry;
	char				temp[ 256 ];
	char const *		psz	= NULL;
	PGPSize				len	= 0;
	PGPBoolean			bBufferBigEnough	= FALSE;
	PGPError			err					= kPGPError_NoErr;

	PGPValidateParam( sizeString >= 1 );
	PGPValidatePtr( pszString );
	*pszString	= '\0';
	
	for( idx = 0; idx < kPGP_NumTCPServiceEntries; ++idx )
	{
		pentry	= &sTCPServices[ idx ];
		if ( pentry->number == uService )
		{
			psz	= pentry->string;
			break;
		}
	}
	
	if ( IsNull( psz ) )
	{
		err = kPGPError_ItemNotFound;

		/* Produce something for missing services */
		sprintf( temp, "%ld", (long)uService );
		psz	= temp;
	}
	
	len	= strlen( psz );
	bBufferBigEnough = ( len + 1 <= sizeString );
	if ( bBufferBigEnough )
	{
		strcpy( pszString, psz );
	}
	else
	{
		pgpCopyMemory( psz, pszString, sizeString - 1 );
		pszString[ sizeString - 1 ]	= '\0';
	}
	
	return( bBufferBigEnough ? err : kPGPError_BufferTooSmall );
}

	PGPError 
PGPGetTCPServiceIndexFromString(
	char *		pszString,
	PGPUInt16 *	puServiceIndex )
{
	PGPUInt32			idx;
	const TextEntry *	pentry;

	PGPValidatePtr( pszString );
	PGPValidatePtr( puServiceIndex );
	
	*puServiceIndex = 0xFFFF;

	for( idx = 0; idx < kPGP_NumTCPServiceEntries; ++idx )
	{
		pentry	= &sTCPServices[ idx ];
		if ( pgpCompareStringsIgnoreCase (pentry->string, pszString) == 0 )
		{
			*puServiceIndex = idx;
			return kPGPError_NoErr;
		}
	}
		
	return kPGPError_ItemNotFound;
}

	PGPError 
PGPGetTCPServiceFromString(
	char *		pszString,
	PGPUInt16 *	puService )
{
	PGPUInt32			idx;
	const TextEntry *	pentry;

	PGPValidatePtr( pszString );
	PGPValidatePtr( puService );
	
	*puService = 0xFFFF;

	for( idx = 0; idx < kPGP_NumTCPServiceEntries; ++idx )
	{
		pentry	= &sTCPServices[ idx ];
		if ( pgpCompareStringsIgnoreCase (pentry->string, pszString) == 0 )
		{
			*puService = pentry->number;
			return kPGPError_NoErr;
		}
	}
		
	return kPGPError_ItemNotFound;
}


	PGPError 
PGPGetICMPTypeString(
	PGPUInt16	uService,
	PGPSize		sizeString,
	char *		pszString )
{
	PGPUInt32			idx;
	const TextEntry *	pentry;
	char				temp[ 256 ];
	char const *		psz	= NULL;
	PGPSize				len	= 0;
	PGPBoolean			bBufferBigEnough	= FALSE;
	PGPError			err					= kPGPError_NoErr;

	PGPValidateParam( sizeString >= 1 );
	PGPValidatePtr( pszString );
	*pszString	= '\0';
	
	for( idx = 0; idx < kPGP_NumICMPTypeEntries; ++idx )
	{
		pentry	= &sICMPTypes[ idx ];
		if ( pentry->number == uService )
		{
			psz	= pentry->string;
			break;
		}
	}
	
	if ( IsNull( psz ) )
	{
		err = kPGPError_ItemNotFound;

		/* Produce something for missing services */
		sprintf( temp, "%ld", (long)uService );
		psz	= temp;
	}
	
	len	= strlen( psz );
	bBufferBigEnough = ( len + 1 <= sizeString );
	if ( bBufferBigEnough )
	{
		strcpy( pszString, psz );
	}
	else
	{
		pgpCopyMemory( psz, pszString, sizeString - 1 );
		pszString[ sizeString - 1 ]	= '\0';
	}
	
	return( bBufferBigEnough ? err : kPGPError_BufferTooSmall );
}


	PGPError 
PGPGetICMPTypeFromString(
	char *		pszString,
	PGPUInt16 *	puService )
{
	PGPUInt32			idx;
	const TextEntry *	pentry;

	PGPValidatePtr( pszString );
	PGPValidatePtr( puService );
	
	*puService = 0xFFFF;

	for( idx = 0; idx < kPGP_NumICMPTypeEntries; ++idx )
	{
		pentry	= &sICMPTypes[ idx ];
		if ( pgpCompareStringsIgnoreCase (pentry->string, pszString) == 0 )
		{
			*puService = pentry->number;
			return kPGPError_NoErr;
		}
	}
		
	return kPGPError_ItemNotFound;
}



/*__Editor_settings____

	Local Variables:
	tab-width: 4
	End:
	vi: ts=4 sw=4
	vim: si
_____________________*/