/*
* Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
* Reserved. This file contains Original Code and/or Modifications of
* Original Code as defined in and that are subject to the Apple Public
* Source License Version 1.0 (the 'License'). You may not use this file
* except in compliance with the License. Please obtain a copy of the
* License at http://www.apple.com/publicsource and read it before using
* this file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
* License for the specific language governing rights and limitations
* under the License."
*
* @APPLE_LICENSE_HEADER_END@
*/
/*
* LUAgent.m
*
* Generic client for lookupd
*
* This is an (almost) abstract superclass for specific
* lookup clients such as NetInfo, DNS, or NIS.
*
* The implementation maintains statistics.
*
* Copyright (c) 1995, NeXT Computer Inc.
* All rights reserved.
* Written by Marc Majka
*/
#import "LUAgent.h"
#import <stdio.h>
#import <string.h>
#import <NetInfo/dsutil.h>
@implementation LUAgent
- (LUAgent *)init
{
[super init];
didInit = YES;
return self;
}
- (const char *)categoryName:(LUCategory)cat
{
switch (cat)
{
case LUCategoryUser: return "user";
case LUCategoryGroup: return "group";
case LUCategoryHost: return "host";
case LUCategoryNetwork: return "network";
case LUCategoryService: return "service";
case LUCategoryProtocol: return "protocol";
case LUCategoryRpc: return "rpc";
case LUCategoryMount: return "mount";
case LUCategoryPrinter: return "printer";
case LUCategoryBootparam: return "bootparam";
case LUCategoryBootp: return "bootp";
case LUCategoryAlias: return "alias";
case LUCategoryNetDomain: return "netdomain";
case LUCategoryEthernet: return "ethernet";
case LUCategoryNetgroup: return "netgroup";
case LUCategoryInitgroups: return "initgroup";
case LUCategoryHostServices: return "hostservice";
default: return NULL;
}
return NULL;
}
- (const char *)categoryPathname:(LUCategory)cat
{
switch (cat)
{
case LUCategoryUser: return "users";
case LUCategoryGroup: return "groups";
case LUCategoryHost: return "hosts";
case LUCategoryNetwork: return "networks";
case LUCategoryService: return "services";
case LUCategoryProtocol: return "protocols";
case LUCategoryRpc: return "rpcs";
case LUCategoryMount: return "mounts";
case LUCategoryPrinter: return "printers";
case LUCategoryBootparam: return "bootparams";
case LUCategoryBootp: return "bootp";
case LUCategoryAlias: return "aliases";
case LUCategoryNetDomain: return "netdomains";
case LUCategoryEthernet: return "ethernets";
case LUCategoryNetgroup: return "netgroups";
case LUCategoryInitgroups: return "initgroups";
case LUCategoryHostServices: return "hostservices";
default: return NULL;
}
return NULL;
}
- (char **)variationsOfEthernetAddress:(void *)addr
{
char **etherAddrs = NULL;
char e[6][3], str[64];
struct ether_addr *ether, etherZero;
int i, j, bit;
if (addr == NULL)
{
bzero(ðerZero, sizeof(struct ether_addr));
ether = ðerZero;
}
else
{
ether = (struct ether_addr *)addr;
}
for (i = 0; i < 64; i++)
{
for (j = 0, bit = 1; j < 6; j++, bit *= 2)
{
if ((i & bit) && (ether->ether_addr_octet[j] <= 15))
{
sprintf(e[j], "0 }
else
{
sprintf(e[j], " }
}
sprintf(str, " if (listIndex(str, etherAddrs) == IndexNull)
{
etherAddrs = appendString(str, etherAddrs);
}
}
return etherAddrs;
}
- (char *)canonicalEthernetAddress:(void *)addr
{
char e[6][3];
static char str[64];
struct ether_addr *ether;
int i, bit;
if (addr == NULL)
{
sprintf(str, "00:00:00:00:00:00");
return str;
}
ether = (struct ether_addr *)addr;
for (i = 0, bit = 1; i < 6; i++, bit *= 2)
{
if ((i & bit) && (ether->ether_addr_octet[i] <= 15))
{
sprintf(e[i], "0 }
else
{
sprintf(e[i], " }
}
sprintf(str, "
return str;
}
/*
* merge values from netgroup b into a
*/
- (void)mergeNetgroup:(LUDictionary *)b into:(LUDictionary *)a
{
char **alist;
char **blist;
char **new = NULL;
int i, len, n;
if (a == nil || b == nil) return;
/* merge names */
alist = [a valuesForKey:"name"];
blist = [b valuesForKey:"name"];
len = [b countForKey:"name"];
if (len < 0) len = 0;
n = 0;
for (i = 0; i < len; i++)
{
if (listIndex(blist[i], alist) == IndexNull)
{
new = appendString(blist[i], new);
n++;
}
}
if (n > 0)
{
[a addValues:new forKey:"name" count:n];
freeList(new);
new = NULL;
}
/* merge netgroup members */
alist = [a valuesForKey:"netgroups"];
blist = [b valuesForKey:"netgroups"];
len = [b countForKey:"netgroups"];
if (len < 0) len = 0;
n = 0;
for (i = 0; i < len; i++)
{
if (listIndex(blist[i], alist) == IndexNull)
{
new = appendString(blist[i], new);
n++;
}
}
if (n > 0)
{
[a addValues:new forKey:"netgroups" count:n];
freeList(new);
new = NULL;
}
/* merge hosts */
alist = [a valuesForKey:"hosts"];
blist = [b valuesForKey:"hosts"];
len = [b countForKey:"hosts"];
if (len < 0) len = 0;
n = 0;
for (i = 0; i < len; i++)
{
if (listIndex(blist[i], alist) == IndexNull)
{
new = appendString(blist[i], new);
n++;
}
}
if (n > 0)
{
[a addValues:new forKey:"hosts" count:n];
freeList(new);
new = NULL;
}
/* merge users */
alist = [a valuesForKey:"users"];
blist = [b valuesForKey:"users"];
len = [b countForKey:"users"];
if (len < 0) len = 0;
n = 0;
for (i = 0; i < len; i++)
{
if (listIndex(blist[i], alist) == IndexNull)
{
new = appendString(blist[i], new);
n++;
}
}
if (n > 0)
{
[a addValues:new forKey:"users" count:n];
freeList(new);
new = NULL;
}
/* merge domains */
alist = [a valuesForKey:"domains"];
blist = [b valuesForKey:"domains"];
len = [b countForKey:"domains"];
if (len < 0) len = 0;
n = 0;
for (i = 0; i < len; i++)
{
if (listIndex(blist[i], alist) == IndexNull)
{
new = appendString(blist[i], new);
n++;
}
}
if (n > 0)
{
[a addValues:new forKey:"domains" count:n];
freeList(new);
new = NULL;
}
}
- (const char *)name
{return NULL;}
- (const char *)shortName
{return NULL;}
- (BOOL)isValid:(LUDictionary *)item
{return NO;}
- (LUDictionary *)userWithName:(char *)name
{return nil;}
- (LUDictionary *)userWithNumber:(int *)number
{return nil;}
- (LUArray *)allUsers {return nil;}
- (LUDictionary *)groupWithName:(char *)name
{return nil;}
- (LUDictionary *)groupWithNumber:(int *)number
{return nil;}
- (LUArray *)allGroups
{return nil;}
- (LUArray *)allGroupsWithUser:(char *)name
{return nil;}
- (LUDictionary *)hostWithName:(char *)name
{return nil;}
- (LUDictionary *)hostWithInternetAddress:(struct in_addr *)addr
{return nil;}
- (LUDictionary *)hostWithEthernetAddress:(struct ether_addr *)addr
{return nil;}
- (LUArray *)allHosts
{return nil;}
- (LUDictionary *)networkWithName:(char *)name
{return nil;}
- (LUDictionary *)networkWithInternetAddress:(struct in_addr *)addr
{return nil;}
- (LUArray *)allNetworks
{return nil;}
- (LUDictionary *)serviceWithName:(char *)name protocol:(char *)prot
{return nil;}
- (LUDictionary *)serviceWithNumber:(int *)number protocol:(char *)prot
{return nil;}
- (LUArray *)allServices
{return nil;}
- (LUDictionary *)protocolWithName:(char *)name
{return nil;}
- (LUDictionary *)protocolWithNumber:(int *)number
{return nil;}
- (LUArray *)allProtocols
{return nil;}
- (LUDictionary *)rpcWithName:(char *)name
{return nil;}
- (LUDictionary *)rpcWithNumber:(int *)number
{return nil;}
- (LUArray *)allRpcs
{return nil;}
- (LUDictionary *)mountWithName:(char *)name
{return nil;}
- (LUArray *)allMounts
{return nil;}
- (LUDictionary *)printerWithName:(char *)name
{return nil;}
- (LUArray *)allPrinters
{return nil;}
- (LUDictionary *)bootparamsWithName:(char *)name
{return nil;}
- (LUArray *)allBootparams
{return nil;}
- (LUDictionary *)bootpWithInternetAddress:(struct in_addr *)addr
{return nil;}
- (LUDictionary *)bootpWithEthernetAddress:(struct ether_addr *)addr
{return nil;}
- (LUDictionary *)aliasWithName:(char *)name
{return nil;}
- (LUArray *)allAliases
{return nil;}
- (LUDictionary *)netgroupWithName:(char *)name
{return nil;}
- (BOOL)inNetgroup:(char *)group
host:(char *)host
user:(char *)user
domain:(char *)domain
{return NO;}
- (LUDictionary *)statistics
{return nil;}
- (void)resetStatistics
{}
- (LUDictionary *)hostsWithService:(char *)name protocol:(char *)protocol
{return nil;}
@end