/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
- *
+ *
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
int afsmon_fs_curr_CBindex = 0; /* current fs CB slot */
-/* Probe number variables. The current probe number is incremented
+/* Probe number variables. The current probe number is incremented
when the first probe from a new probe cycle is received. The prev probe
number is incremented when the last probe of the current cycle is
received. This difference is because of the purpose for which these
int afsmon_cm_curr_CBindex = 0; /* current cm CB slot */
-/* Probe number variables. The current probe number is incremented
+/* Probe number variables. The current probe number is incremented
when the first probe from a new probe cycle is received. The prev probe
number is incremented when the last probe of the current cycle is
received. This difference is because of the purpose for which these
int num_cm_alerts;
int numHosts_oncm_alerts;
-/* flag to indicate that atleast one probe cycle has completed and
+/* flag to indicate that atleast one probe cycle has completed and
data is available for updating the display */
extern int fs_Data_Available;
extern int cm_Data_Available;
user wishes to display only the vcache statistics then the following array
will contain indices 2 to 14 corresponding to the position of the
vcache data items in the fs_varNames[] array. If the config file contains
-no "show fs .." directives, it will contain the indices of all the
+no "show fs .." directives, it will contain the indices of all the
items in the fs_varNames[] array */
short fs_Display_map[NUM_FS_STAT_ENTRIES];
extern int cm_currPage; /* current page number in the Cache Managers frame */
extern int cm_curr_LCol; /* current leftmost column on display on CM frame */
-/* File server and Cache manager data is classified into sections &
+/* File server and Cache manager data is classified into sections &
groups to help the user choose what he wants displayed */
extern char *fs_categories[]; /* file server data category names */
extern char *cm_categories[]; /* cache manager data category names */
#ifdef HAVE_STRCASESTR
extern char * strcasestr(const char *, const char *);
#else
-/*
- strcasestr(): Return first occurence of pattern s2 in s1, case
- insensitive.
+/*
+ strcasestr(): Return first occurence of pattern s2 in s1, case
+ insensitive.
This routine is required since I made pattern matching of the
- config file to be case insensitive.
+ config file to be case insensitive.
*/
char *
len2 = strlen(s2);
if (len1 < len2)
- return ((char *)NULL);
+ return (NULL);
ptr = s1;
ptr++;
len1--;
}
- return ((char *)NULL);
+ return (NULL);
}
#endif
*
* Description
* Exit gracefully from the afsmonitor. Frees memory where appropriate,
- * cleans up after gtx and closes all open file descriptors. If a user
+ * cleans up after gtx and closes all open file descriptors. If a user
* provided threshold handler is to be exec'ed then gtx cleanup is
- * not performed and an exec() is made instead of an exit().
+ * not performed and an exec() is made instead of an exit().
*
* Returns
* Nothing.
*
- * Comments
- * This function is called to execute a user handler only
+ * Comments
+ * This function is called to execute a user handler only
* by a child process.
- *
+ *
*----------------------------------------------------------------------*/
int
struct afsmon_cm_Results_list *next_cmlist;
struct xstat_cm_ProbeResults *tmp_xstat_cmPR;
struct afsmon_hostEntry *curr_hostEntry;
- struct afsmon_hostEntry *prev_hostEntry;
+ struct afsmon_hostEntry *next_hostEntry;
int i;
int j;
int bufslot;
if (afsmon_debug)
fprintf(debugFD, "Deallocating FS hostEntries ..");
curr_hostEntry = FSnameList;
- for (i = 0; i < numFS; i++) {
- prev_hostEntry = curr_hostEntry;
+ while (curr_hostEntry) {
+ next_hostEntry = curr_hostEntry->next;
if (curr_hostEntry->thresh != NULL)
free(curr_hostEntry->thresh);
free(curr_hostEntry);
- if (afsmon_debug)
- fprintf(debugFD, " %d", i);
- curr_hostEntry = prev_hostEntry->next;
+ curr_hostEntry = next_hostEntry;
}
if (afsmon_debug)
fprintf(debugFD, "\n");
if (afsmon_debug)
fprintf(debugFD, "Deallocating CM hostEntries ..");
curr_hostEntry = CMnameList;
- for (i = 0; i < numCM; i++) {
- prev_hostEntry = curr_hostEntry;
+ while (curr_hostEntry) {
+ next_hostEntry = curr_hostEntry->next;
if (curr_hostEntry->thresh != NULL)
free(curr_hostEntry->thresh);
free(curr_hostEntry);
- if (afsmon_debug)
- fprintf(debugFD, " %d", i);
- curr_hostEntry = prev_hostEntry->next;
+ curr_hostEntry = next_hostEntry;
}
if (afsmon_debug)
fprintf(debugFD, "\n");
if (*a_hostName == '\0')
return (-1);
- curr_item = (struct afsmon_hostEntry *)
- malloc(sizeof(struct afsmon_hostEntry));
+ curr_item = malloc(sizeof(struct afsmon_hostEntry));
if (curr_item == (struct afsmon_hostEntry *)0) {
fprintf(stderr, "Failed to allocate space for FS nameList\n");
return (-1);
if (*a_hostName == '\0')
return (-1);
- curr_item = (struct afsmon_hostEntry *)
- malloc(sizeof(struct afsmon_hostEntry));
+ curr_item = malloc(sizeof(struct afsmon_hostEntry));
if (curr_item == (struct afsmon_hostEntry *)0) {
fprintf(stderr, "Failed to allocate space for CM nameList\n");
return (-1);
*
* Description
* Parse the threshold entry line in the config file. This function is
- * called in the the first pass of the config file. It checks the syntax
+ * called in the the first pass of the config file. It checks the syntax
* of the config lines and verifies their positional validity - eg.,
* a cm threshold cannot appear after a fs hostname entry, etc.
* It also counts the thresholds applicable to each host.
* for cache managers. For global thresholds the info is recorded for
* all the hosts. This function is called in the second pass of the
* config file. In the first pass a count of the number of global
- * thresholds is determined and this information is used in this
+ * thresholds is determined and this information is used in this
* routine. If threshold entries are duplicated the first entry is
* overwritten.
* Each threshold entry also has an index field. This is a positional
* This data is mapped to the screen thru fs_Display_map[] and
* cm_Display_map[]. This routine parses the "show" entry against the
* section/group names in the [fs/cm]_categories[] array. If there is
- * no match it tries to match it against a variable name in
+ * no match it tries to match it against a variable name in
* [fs/cm]_varNames[] array. In each case the corresponding indices to
- * the data is the [fs/cm]_displayInfo[] is recorded.
+ * the data is the [fs/cm]_displayInfo[] is recorded.
*
* Returns:
* Success: 0
/* if it is a section/group name, find it in the fs_categories[] array */
found = 0;
- if (strcasestr(arg2, "_section") != (char *)NULL
- || strcasestr(arg2, "_group") != (char *)NULL) {
+ if (strcasestr(arg2, "_section") != NULL
+ || strcasestr(arg2, "_group") != NULL) {
idx = 0;
while (idx < FS_NUM_DATA_CATEGORIES) {
sscanf(fs_categories[idx], "%s %d %d", catName, &fromIdx,
/* if it is a group name, read its start/end indices and fill in the
* fs_Display_map[]. */
- if (strcasestr(arg2, "_group") != (char *)NULL) {
+ if (strcasestr(arg2, "_group") != NULL) {
if (fromIdx < 0 || toIdx < 0 || fromIdx > NUM_FS_STAT_ENTRIES
|| toIdx > NUM_FS_STAT_ENTRIES)
/* if it is a section name, get the count of number of groups in it and
* for each group fill in the start/end indices in the fs_Display_map[] */
- if (strcasestr(arg2, "_section") != (char *)NULL) {
+ if (strcasestr(arg2, "_section") != NULL) {
/* fromIdx is actually the number of groups in thi section */
numGroups = fromIdx;
/* for each group in section */
/* if it is a section/group name, find it in the cm_categories[] array */
found = 0;
- if (strcasestr(arg2, "_section") != (char *)NULL
- || strcasestr(arg2, "_group") != (char *)NULL) {
+ if (strcasestr(arg2, "_section") != NULL
+ || strcasestr(arg2, "_group") != NULL) {
idx = 0;
while (idx < CM_NUM_DATA_CATEGORIES) {
sscanf(cm_categories[idx], "%s %d %d", catName, &fromIdx,
/* if it is a group name, read its start/end indices and fill in the
* cm_Display_map[]. */
- if (strcasestr(arg2, "_group") != (char *)NULL) {
+ if (strcasestr(arg2, "_group") != NULL) {
if (fromIdx < 0 || toIdx < 0 || fromIdx > NUM_CM_STAT_ENTRIES
|| toIdx > NUM_CM_STAT_ENTRIES)
/* if it is a section name, get the count of number of groups in it and
* for each group fill in the start/end indices in the cm_Display_map[] */
- if (strcasestr(arg2, "_section") != (char *)NULL) {
+ if (strcasestr(arg2, "_section") != NULL) {
/* fromIdx is actually the number of groups in thi section */
numGroups = fromIdx;
/* for each group in section */
* process_config_file()
*
* Description:
- * Parse config file entries in two passes. In the first pass:
+ * Parse config file entries in two passes. In the first pass:
* - the syntax of all the entries is checked
- * - host names are noted and the FSnamesList and CMnamesList
- * constructed.
- * - a count of the global thresholds and local thresholds of
- * each host are counted.
+ * - host names are noted and the FSnamesList and CMnamesList
+ * constructed.
+ * - a count of the global thresholds and local thresholds of
+ * each host are counted.
* - "show" entries are processed.
* In the second pass:
- * - thresholds are stored
+ * - thresholds are stored
*
* Returns:
* Success: 0
char *handlerPtr; /* ptr to pass theresh handler string */
int code = 0; /* error code */
int linenum = 0; /* config file line number */
- int threshCount; /* count of thresholds for each server */
int error_in_config; /* syntax errors in config file ?? */
int i;
int numBytes;
numFS = 0;
numCM = 0;
- threshCount = 0;
error_in_config = 0; /* flag to note if config file has syntax errors */
while ((fgets(line, CFG_STR_LEN, configFD)) != NULL) {
}
/* the threshold count of all hosts in increased by 1 for each global
- * threshold. If one of the hosts has a local threshold for the same
+ * threshold. If one of the hosts has a local threshold for the same
* variable it would end up being counted twice. whats a few bytes of memory
* wasted anyway ? */
}
if (curr_host->numThresh) {
numBytes = curr_host->numThresh * sizeof(struct Threshold);
- curr_host->thresh = (struct Threshold *)malloc(numBytes);
+ curr_host->thresh = malloc(numBytes);
if (curr_host->thresh == NULL) {
fprintf(stderr, "[ %s ] Memory Allocation error 1", rn);
afsmon_Exit(25);
}
if (curr_host->numThresh) {
numBytes = curr_host->numThresh * sizeof(struct Threshold);
- curr_host->thresh = (struct Threshold *)malloc(numBytes);
+ curr_host->thresh = malloc(numBytes);
if (curr_host->thresh == NULL) {
fprintf(stderr, "[ %s ] Memory Allocation error 2", rn);
afsmon_Exit(35);
strncpy(last_cmHost, he->h_name, HOST_NAME_LEN);
} else if (strcasecmp(opcode, "thresh") == 0) {
/* if we have a threshold handler it may have arguments
- * and the sscanf() above would not get them, so do the
+ * and the sscanf() above would not get them, so do the
* following */
if (strlen(arg4)) {
handlerPtr = line;
break;
case AFS_XSTATSCOLL_CBSTATS:
index = 1;
+ break;
default:
- if (index < 0) {
- fprintf(stderr, "[ %s ] collection number %d is out of range.\n",
- rn, xstat_fs_Results.collectionNumber);
- afsmon_Exit(51);
- }
+ fprintf(stderr, "[ %s ] collection number %d is out of range.\n",
+ rn, xstat_fs_Results.collectionNumber);
+ afsmon_Exit(51);
}
/* If a new probe cycle started, mark the list in the current buffer
* fs_Results_ltoa()
*
* Description:
- * The results of xstat probes are stored in a string format in
+ * The results of xstat probes are stored in a string format in
* the arrays curr_fsData and prev_fsData. The information stored in
- * prev_fsData is copied to the screen.
- * This function converts xstat FS results from longs to strings and
+ * prev_fsData is copied to the screen.
+ * This function converts xstat FS results from longs to strings and
* place them in the given buffer (a pointer to an item in curr_fsData).
* When a probe cycle completes, curr_fsData is copied to prev_fsData
* in afsmon_FS_Hnadler().
{
afs_int32 *srcbuf;
struct fs_stats_FullPerfStats *fullPerfP;
+ struct fs_stats_FullPerfStats buffer;
int idx;
int i, j;
afs_int32 *tmpbuf;
- afs_int32 numInt32s;
-
- fullPerfP = (struct fs_stats_FullPerfStats *)
- (a_fsResults->data.AFS_CollData_val);
+ int code;
- /* there are two parts to the xstat FS statistics
+ /* there are two parts to the xstat FS statistics
* - fullPerfP->overall which give the overall performance statistics, and
* - fullPerfP->det which gives detailed info about file server operation
* execution times */
- /*
- * Unfortunately, the full perf stats contain timeval structures which
- * do not have the same size everywhere. Avoid displaying gargbage,
- * but at least try to show the overall stats.
- */
- numInt32s = a_fsResults->data.AFS_CollData_len;
- if (numInt32s !=
- (sizeof(struct fs_stats_FullPerfStats) / sizeof(afs_int32))) {
- srcbuf = a_fsResults->data.AFS_CollData_val;
+ code = xstat_fs_DecodeFullPerfStats(&fullPerfP,
+ a_fsResults->data.AFS_CollData_val,
+ a_fsResults->data.AFS_CollData_len,
+ &buffer);
+ if (code) {
+ /* Not able to decode the full perf stats. Avoid displaying garbage. */
for (i = 0; i < NUM_FS_STAT_ENTRIES; i++) {
- if (i < numInt32s && i < NUM_XSTAT_FS_AFS_PERFSTATS_LONGS) {
- sprintf(a_fsData->data[i], "%d", srcbuf[i]);
- } else {
- sprintf(a_fsData->data[i], "%s", "--");
- }
+ sprintf(a_fsData->data[i], "%s", "--");
}
return 0;
}
* execute_thresh_handler()
*
* Description:
- * Execute a threshold handler. An agrv[] array of pointers is
- * constructed from the given data. A child process is forked
+ * Execute a threshold handler. An agrv[] array of pointers is
+ * constructed from the given data. A child process is forked
* which immediately calls afsmon_Exit() with indication that a
- * threshold handler is to be exec'ed insted of exiting.
+ * threshold handler is to be exec'ed insted of exiting.
*
* Returns:
* Success: 0
char fileName[256]; /* file name to execute */
int i;
char *ch;
- int code;
int argNum;
int anotherArg; /* boolean used to flag if another arg is available */
if (fork() == 0) {
exec_fsThreshHandler = 1;
- code = afsmon_Exit(60);
+ afsmon_Exit(60);
}
return (0);
* Description:
* Checks the thresholds and sets the overflow flag. Recall that the
* thresholds for each host are stored in the hostEntry lists
- * [fs/cm]nameList arrays. The probe results are passed to this
+ * [fs/cm]nameList arrays. The probe results are passed to this
* function in the display-ready format - ie., as strings. Though
* this looks stupid the overhead incurred in converting the strings
- * back to floats and comparing them is insignificant and
- * programming is easier this way.
+ * back to floats and comparing them is insignificant and
+ * programming is easier this way.
* The threshold flags are a part of the display structures
* curr_[fs/cm]Data.
*
* Description:
* Does the following:
* - if the probe number changed (ie, a cycle completed) curr_fsData
- * is copied to prev_fsData, curr_fsData zeroed and refresh the
+ * is copied to prev_fsData, curr_fsData zeroed and refresh the
* overview screen and file server screen with the new data.
* - store the results of the current probe from xstat_fs_Results into
* curr_fsData. ie., convert longs to strings.
- * - check the thresholds
+ * - check the thresholds
*
* Returns:
* Success: 0
}
/* Check the status of the probe. If it succeeded, we store its
- * results in the display data structure. If it failed we only mark
+ * results in the display data structure. If it failed we only mark
* the failed status in the display data structure. */
if (a_fsResults->probeOK) { /* 1 => notOK the xstat results */
fs_Results_ltoa(curr_fsDataP, a_fsResults);
/* compare with thresholds and set the overflow flags.
- * note that the threshold information is in the hostEntry structure and
+ * note that the threshold information is in the hostEntry structure and
* each threshold item has a positional index associated with it */
/* locate the hostEntry for this host */
}
}
- /* Update current probe number and circular buffer index. if current
+ /* Update current probe number and circular buffer index. if current
* probenum changed make sure it is only by 1 */
newProbeCycle = 0;
/* store the results of the current probe in the fs data display structure.
* if the current probe number changed, swap the current and previous display
- * structures. note that the display screen is updated from these structures
+ * structures. note that the display screen is updated from these structures
* and should start showing the data of the just completed probe cycle */
save_FS_data_forDisplay(&xstat_fs_Results);
-/*----------------------------------------------------------------------- *
- * Print_CM_CB()
+/*----------------------------------------------------------------------- *
+ * Print_CM_CB()
*
* Description:
* Debug routine.
- * Prints the Cache Manager circular buffer
+ * Prints the Cache Manager circular buffer
*----------------------------------------------------------------------*/
void
* cm_Results_ltoa()
*
* Description:
- * The results of xstat probes are stored in a string format in
+ * The results of xstat probes are stored in a string format in
* the arrays curr_cmData and prev_cmData. The information stored in
- * prev_cmData is copied to the screen.
- * This function converts xstat FS results from longs to strings and
+ * prev_cmData is copied to the screen.
+ * This function converts xstat FS results from longs to strings and
* places them in the given buffer (a pointer to an item in curr_cmData).
* When a probe cycle completes, curr_cmData is copied to prev_cmData
* in afsmon_CM_Handler().
/* There are 4 parts to CM statistics
* - Overall performance statistics (including up/down statistics)
- * - This CMs FS RPC operations info
+ * - This CMs FS RPC operations info
* - This CMs FS RPC errors info
* - This CMs FS transfers info
* - Authentication info
* Description:
* Checks the thresholds and sets the overflow flag. Recall that the
* thresholds for each host are stored in the hostEntry lists
- * [fs/cm]nameList arrays. The probe results are passed to this
+ * [fs/cm]nameList arrays. The probe results are passed to this
* function in the display-ready format - ie., as strings. Though
* this looks stupid the overhead incurred in converting the strings
- * back to floats and comparing them is insignificant and
- * programming is easier this way.
+ * back to floats and comparing them is insignificant and
+ * programming is easier this way.
* The threshold flags are a part of the display structures
* curr_[fs/cm]Data.
*
* Description:
* Does the following:
* - if the probe number changed (ie, a cycle completed) curr_cmData
- * is copied to prev_cmData, curr_cmData zeroed and refresh the
+ * is copied to prev_cmData, curr_cmData zeroed and refresh the
* overview screen and file server screen with the new data.
* - store the results of the current probe from xstat_cm_Results into
* curr_cmData. ie., convert longs to strings.
- * - check the thresholds
+ * - check the thresholds
*
* Returns:
* Success: 0
}
/* Check the status of the probe. If it succeeded, we store its
- * results in the display data structure. If it failed we only mark
+ * results in the display data structure. If it failed we only mark
* the failed status in the display data structure. */
cm_Results_ltoa(curr_cmDataP, a_cmResults);
/* compare with thresholds and set the overflow flags.
- * note that the threshold information is in the hostEntry structure and
+ * note that the threshold information is in the hostEntry structure and
* each threshold item has a positional index associated with it */
/* locate the hostEntry for this host */
}
}
- /* Update current probe number and circular buffer index. if current
+ /* Update current probe number and circular buffer index. if current
* probenum changed make sure it is only by 1 */
newProbeCycle = 0;
/* store the results of the current probe in the cm data display structure.
* if the current probe number changed, swap the current and previous display
- * structures. note that the display screen is updated from these structures
+ * structures. note that the display screen is updated from these structures
* and should start showing the data of the just completed probe cycle */
save_CM_data_forDisplay(&xstat_cm_Results);
afsmon_fs_ResultsCB[i].probeNum = 0;
}
- /* create a list of numFS items to store fs probe results for
+ /* create a list of numFS items to store fs probe results for
* each slot in CB */
if (numFS) { /* if we have file servers to monitor */
while (numfs--) {
/* if any of these mallocs fail we only need to free the memory we
- * have allocated in this iteration. the rest of it which is in a
+ * have allocated in this iteration. the rest of it which is in a
* proper linked list will be freed in afsmon_Exit */
/* allocate memory for an fs list item */
afsmon_cm_ResultsCB[i].probeNum = 0;
}
- /* create a list of numCM items to store fs probe results for
+ /* create a list of numCM items to store fs probe results for
* each slot in CB */
if (numCM) { /* if we have file servers to monitor */
while (numcm--) {
/* if any of these mallocs fail we only need to free the memory we
- * have allocated in this iteration. the rest of it which is in a
+ * have allocated in this iteration. the rest of it which is in a
* proper linked list will be freed in afsmon_Exit */
/* allocate memory for an fs list item */
/* >>> need to allocate rx connection info structure here <<< */
new_cmPR->data.AFSCB_CollData_val =
- (afs_int32 *) malloc(XSTAT_CM_FULLPERF_RESULTS_LEN
- * sizeof(afs_int32));
+ malloc(XSTAT_CM_FULLPERF_RESULTS_LEN
+ *sizeof(afs_int32));
if (new_cmPR->data.AFSCB_CollData_val == NULL) {
free(new_cmlist_item);
free(new_cmPR->connP);
*
* Description:
* Allocate and initialize the buffers used for printing results
- * to the display screen. These buffers store the current and
- * previous probe results in ascii format.
+ * to the display screen. These buffers store the current and
+ * previous probe results in ascii format.
*
* Returns:
* Success: 0
/* we need two instances of this structure - one (curr_fsData) for storing
* the results of the fs probes currently in progress and another (prev_fsData)
* for the last completed probe. The display is updated from the contents of
- * prev_fsData. The pointers curr_fsData & prev_fsData are switched whenever
+ * prev_fsData. The pointers curr_fsData & prev_fsData are switched whenever
* the probe number changes */
if (numFS) {
numBytes = numFS * sizeof(struct fs_Display_Data);
- curr_fsData = (struct fs_Display_Data *)malloc(numBytes);
+ curr_fsData = malloc(numBytes);
if (curr_fsData == (struct fs_Display_Data *)0) {
fprintf(stderr, "[ %s ] Memory allocation failure\n", rn);
return (-1);
memset(curr_fsData, 0, numBytes);
numBytes = numFS * sizeof(struct fs_Display_Data);
- prev_fsData = (struct fs_Display_Data *)malloc(numBytes);
+ prev_fsData = malloc(numBytes);
if (prev_fsData == (struct fs_Display_Data *)0) {
fprintf(stderr, "[ %s ] Memory allocation failure\n", rn);
return (-5);
if (numCM) {
numBytes = numCM * sizeof(struct cm_Display_Data);
- curr_cmData = (struct cm_Display_Data *)malloc(numBytes);
+ curr_cmData = malloc(numBytes);
if (curr_cmData == (struct cm_Display_Data *)0) {
fprintf(stderr, "[ %s ] Memory allocation failure\n", rn);
return (-10);
memset(curr_cmData, 0, numBytes);
numBytes = numCM * sizeof(struct cm_Display_Data);
- prev_cmData = (struct cm_Display_Data *)malloc(numBytes);
+ prev_cmData = malloc(numBytes);
if (prev_cmData == (struct cm_Display_Data *)0) {
fprintf(stderr, "[ %s ] Memory allocation failure\n", rn);
return (-15);
* Description:
* This is where we start it all. Initialize an array of sockets for
* file servers and cache cache managers and call the xstat_[fs/cm]_Init
- * routines. The last step is to call the gtx input server which
+ * routines. The last step is to call the gtx input server which
* grabs control of the keyboard.
*
* Returns:
/* Allocate an array of sockets for each fileserver we monitor */
FSsktbytes = numFS * sizeof(struct sockaddr_in);
- FSSktArray = (struct sockaddr_in *)malloc(FSsktbytes);
+ FSSktArray = malloc(FSsktbytes);
if (FSSktArray == (struct sockaddr_in *)0) {
fprintf(stderr,
"[ %s ] cannot malloc %d sockaddr_ins for fileservers\n",
/* Allocate an array of sockets for each cache manager we monitor */
CMsktbytes = numCM * sizeof(struct sockaddr_in);
- CMSktArray = (struct sockaddr_in *)malloc(CMsktbytes);
+ CMSktArray = malloc(CMsktbytes);
if (CMSktArray == (struct sockaddr_in *)0) {
fprintf(stderr,
"[ %s ] cannot malloc %d sockaddr_ins for CM entries\n",
}
strncpy(curr_CM->hostName, he->h_name, HOST_NAME_LEN); /* complete name */
memcpy(&(curr_skt->sin_addr.s_addr), he->h_addr, 4);
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
- curr_skt->sin_family = AF_INET; /*Internet family */
-#else
- curr_skt->sin_family = htons(AF_INET); /*Internet family */
-#endif
- curr_skt->sin_port = htons(7001); /*Cache Manager port */
+ curr_skt->sin_family = AF_INET;
+ curr_skt->sin_port = htons(7001); /* Cache Manager port */
#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
curr_skt->sin_len = sizeof(struct sockaddr_in);
#endif
/* end of process cache manager entries */
- /* if only one probe was required setup a waiting process for the
+ /* if only one probe was required setup a waiting process for the
* termination signal */
if (afsmon_onceOnly) {
code = LWP_WaitProcess(&terminationEvent);
FSnameList = (struct afsmon_hostEntry *)0;
CMnameList = (struct afsmon_hostEntry *)0;
- /* The -config option is mutually exclusive with the -fshosts,-cmhosts
+ /* The -config option is mutually exclusive with the -fshosts,-cmhosts
* options */
if (as->parms[P_CONFIG].items) {
/* If a file server host is specified on the command line we reuse
- * parse_hostEntry() function . Just the pass the info as if it were
+ * parse_hostEntry() function . Just the pass the info as if it were
* read off the config file */
if (as->parms[P_FSHOSTS].items) {
"number of buffer slots");
/*
- * Parse command-line switches & execute afsmonitor
+ * Parse command-line switches & execute afsmonitor
*/
code = cmd_Dispatch(argc, argv);
git://git.openafs.org / openafs.git / blobdiff