/*****************************************************************************\
 *  slurm_errno.c - error codes and functions for slurm
 ******************************************************************************
 *  Copyright (C) 2002-2007 The Regents of the University of California.
 *  Copyright (C) 2008-2010 Lawrence Livermore National Security.
 *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
 *  Written by Jim Garlick <garlick@llnl.gov>, et. al.
 *  CODE-OCEC-09-009. All rights reserved.
 *
 *  This file is part of Slurm, a resource management program.
 *  For details, see <https://slurm.schedmd.com/>.
 *  Please also read the included file: DISCLAIMER.
 *
 *  Slurm is free software; you can redistribute it and/or modify it under
 *  the terms of the GNU General Public License as published by the Free
 *  Software Foundation; either version 2 of the License, or (at your option)
 *  any later version.
 *
 *  In addition, as a special exception, the copyright holders give permission
 *  to link the code of portions of this program with the OpenSSL library under
 *  certain conditions as described in each individual source file, and
 *  distribute linked combinations including the two. You must obey the GNU
 *  General Public License in all respects for all of the code used other than
 *  OpenSSL. If you modify file(s) with this exception, you may extend this
 *  exception to your version of the file(s), but you are not obligated to do
 *  so. If you do not wish to do so, delete this exception statement from your
 *  version.  If you delete this exception statement from all source files in
 *  the program, then also delete it here.
 *
 *  Slurm is distributed in the hope that it will be useful, but WITHOUT ANY
 *  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 *  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 *  details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with Slurm; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA.
\*****************************************************************************/

/*  This implementation relies on "overloading" the libc errno by
 *  partitioning its domain into system (<1000) and Slurm (>=1000) values.
 *  API users should call slurm_strerror() to convert all errno values to
 *  their description strings.
 */

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "slurm/slurm_errno.h"

/*
 * Each table entry needs the macro directly (to be translated into the raw
 * value) alongside the text string representation. Rather than duplicate them
 * - and risk them getting out of sync on a bad copy + paste - use this macro
 * to construct each row.
 */
#define ERRTAB_ENTRY(_e) _e, #_e

/* Add new error values to slurm/slurm_errno.h, and their descriptions to this table */
slurm_errtab_t slurm_errtab[] = {
	{ ERRTAB_ENTRY(SLURM_SUCCESS), "No error"},
	{ ERRTAB_ENTRY(SLURM_ERROR), "Unspecified error"},
	{ ERRTAB_ENTRY(EINPROGRESS), "Operation now in progress"},

	/* General Message error codes */
	{ ERRTAB_ENTRY(SLURM_UNEXPECTED_MSG_ERROR),
	  "Unexpected message received" 			},
	{ ERRTAB_ENTRY(SLURM_COMMUNICATIONS_CONNECTION_ERROR),
	  "Communication connection failure"   			},
	{ ERRTAB_ENTRY(SLURM_COMMUNICATIONS_SEND_ERROR),
	  "Message send failure"				},
	{ ERRTAB_ENTRY(SLURM_COMMUNICATIONS_RECEIVE_ERROR),
	  "Message receive failure"				},
	{ ERRTAB_ENTRY(SLURM_COMMUNICATIONS_SHUTDOWN_ERROR),
	  "Communication shutdown failure"			},
	{ ERRTAB_ENTRY(SLURM_PROTOCOL_VERSION_ERROR),
	  "Incompatible versions of client and server code"	},
        { ERRTAB_ENTRY(SLURM_PROTOCOL_IO_STREAM_VERSION_ERROR),
          "I/O stream version number error"                     },
        { ERRTAB_ENTRY(SLURM_PROTOCOL_AUTHENTICATION_ERROR),
          "Protocol authentication error"                       },
        { ERRTAB_ENTRY(SLURM_PROTOCOL_INSANE_MSG_LENGTH),
          "Insane message length"                               },
	{ ERRTAB_ENTRY(SLURM_MPI_PLUGIN_NAME_INVALID),
	  "Invalid MPI plugin name"                             },
	{ ERRTAB_ENTRY(SLURM_MPI_PLUGIN_PRELAUNCH_SETUP_FAILED),
	  "MPI plugin's pre-launch setup failed"                },
	{ ERRTAB_ENTRY(SLURM_PLUGIN_NAME_INVALID),
	  "Plugin initialization failed"			},
	{ ERRTAB_ENTRY(SLURM_UNKNOWN_FORWARD_ADDR),
	  "Can't find an address, check slurm.conf"		},
	{ ERRTAB_ENTRY(SLURM_COMMUNICATIONS_MISSING_SOCKET_ERROR),
	  "Unexpected missing socket error"			},
	{ ERRTAB_ENTRY(SLURM_COMMUNICATIONS_INVALID_INCOMING_FD),
	  "Unable to process incoming file descriptor" },
	{ ERRTAB_ENTRY(SLURM_COMMUNICATIONS_INVALID_OUTGOING_FD),
	  "Unable to process outgoing file descriptor" },
	{ ERRTAB_ENTRY(SLURM_COMMUNICATIONS_INVALID_FD),
	  "Unable to process incoming and outgoing file descriptors" },

	/* communication failures to/from slurmctld */
	{ ERRTAB_ENTRY(SLURMCTLD_COMMUNICATIONS_CONNECTION_ERROR),
	  "Unable to contact slurm controller (connect failure)" },
	{ ERRTAB_ENTRY(SLURMCTLD_COMMUNICATIONS_SEND_ERROR),
	  "Unable to contact slurm controller (send failure)"    },
	{ ERRTAB_ENTRY(SLURMCTLD_COMMUNICATIONS_RECEIVE_ERROR),
	  "Unable to contact slurm controller (receive failure)" },
	{ ERRTAB_ENTRY(SLURMCTLD_COMMUNICATIONS_SHUTDOWN_ERROR),
	  "Unable to contact slurm controller (shutdown failure)"},
	{ ERRTAB_ENTRY(SLURMCTLD_COMMUNICATIONS_BACKOFF),
	  "Rate limit exceeded, please retry momentarily"},
	{ ERRTAB_ENTRY(SLURMCTLD_COMMUNICATIONS_HARD_DROP),
	  "Rate limit exceeded, please retry later"},

	/* _info.c/communication layer RESPONSE_SLURM_RC message codes */

	/* Not really an error */
	{ ERRTAB_ENTRY(SLURM_NO_CHANGE_IN_DATA),
	  "Data has not changed since time specified"		},

	/* slurmctld error codes */

	{ ERRTAB_ENTRY(ESLURM_INVALID_PARTITION_NAME),
	  "Invalid partition name specified"			},
	{ ERRTAB_ENTRY(ESLURM_DEFAULT_PARTITION_NOT_SET),
	  "No partition specified or system default partition"	},
	{ ERRTAB_ENTRY(ESLURM_ACCESS_DENIED),
	  "Access/permission denied"				},
	{ ERRTAB_ENTRY(ESLURM_JOB_MISSING_REQUIRED_PARTITION_GROUP),
	  "User's group not permitted to use this partition"	},
	{ ERRTAB_ENTRY(ESLURM_REQUESTED_NODES_NOT_IN_PARTITION),
	  "Requested nodes not in this partition"		},
	{ ERRTAB_ENTRY(ESLURM_TOO_MANY_REQUESTED_CPUS),
	  "More processors requested than permitted"		},
	{ ERRTAB_ENTRY(ESLURM_INVALID_NODE_COUNT),
	  "Node count specification invalid"			},
	{ ERRTAB_ENTRY(ESLURM_ERROR_ON_DESC_TO_RECORD_COPY),
	  "Unable to create job record, try again"		},
	{ ERRTAB_ENTRY(ESLURM_JOB_MISSING_SIZE_SPECIFICATION),
	  "Job size specification needs to be provided"		},
	{ ERRTAB_ENTRY(ESLURM_JOB_SCRIPT_MISSING),
	  "Job script not specified"				},
	{ ERRTAB_ENTRY(ESLURM_USER_ID_MISSING),
	  "Invalid user id"					},
	{ ERRTAB_ENTRY(ESLURM_DUPLICATE_JOB_ID),
	  "Duplicate job id"					},
	{ ERRTAB_ENTRY(ESLURM_PATHNAME_TOO_LONG),
	  "Pathname of a file, directory or other parameter too long" },
	{ ERRTAB_ENTRY(ESLURM_NOT_TOP_PRIORITY),
	  "Immediate execution impossible, insufficient priority" },
	{ ERRTAB_ENTRY(ESLURM_REQUESTED_NODE_CONFIG_UNAVAILABLE),
	  "Requested node configuration is not available"	},
	{ ERRTAB_ENTRY(ESLURM_REQUESTED_PART_CONFIG_UNAVAILABLE),
	  "Requested partition configuration not available now" },
	{ ERRTAB_ENTRY(ESLURM_NODES_BUSY),
	  "Requested nodes are busy"				},
	{ ERRTAB_ENTRY(ESLURM_INVALID_JOB_ID),
	  "Invalid job id specified"				},
	{ ERRTAB_ENTRY(ESLURM_INVALID_NODE_NAME),
	  "Invalid node name specified"				},
	{ ERRTAB_ENTRY(ESLURM_INVALID_CORE_CNT),
	  "Core count for reservation node list is not consistent!" },
	{ ERRTAB_ENTRY(ESLURM_WRITING_TO_FILE),
	  "I/O error writing script/environment to file"	},
	{ ERRTAB_ENTRY(ESLURM_TRANSITION_STATE_NO_UPDATE),
	  "Job can not be altered now, try again later"		},
	{ ERRTAB_ENTRY(ESLURM_ALREADY_DONE),
	  "Job/step already completing or completed"		},
	{ ERRTAB_ENTRY(ESLURM_INTERCONNECT_FAILURE),
	  "Error configuring interconnect"			},
	{ ERRTAB_ENTRY(ESLURM_BAD_DIST),
	  "Task distribution specification invalid"		},
	{ ERRTAB_ENTRY(ESLURM_JOB_PENDING),
	  "Job is pending execution"				},
	{ ERRTAB_ENTRY(ESLURM_BAD_TASK_COUNT),
	  "Task count specification invalid"			},
	{ ERRTAB_ENTRY(ESLURM_INVALID_JOB_CREDENTIAL),
	  "Error generating job credential"			},
	{ ERRTAB_ENTRY(ESLURM_IN_STANDBY_MODE),
	  "Slurm backup controller in standby mode"		},
	{ ERRTAB_ENTRY(ESLURM_INVALID_NODE_STATE),
	  "Invalid node state specified"			},
	{ ERRTAB_ENTRY(ESLURM_INVALID_FEATURE),
	  "Invalid feature specification"			},
	{ ERRTAB_ENTRY(ESLURM_INVALID_AUTHTYPE_CHANGE),
	  "AuthType change requires restart of all Slurm daemons and "
	  "commands to take effect"},
	{ ERRTAB_ENTRY(ESLURM_ACTIVE_FEATURE_NOT_SUBSET),
	  "Active features not subset of available features"	},
	{ ERRTAB_ENTRY(ESLURM_INVALID_CRED_TYPE_CHANGE),
	  "CredType change requires restart of all Slurm daemons "
	  "to take effect"					},
	{ ERRTAB_ENTRY(ESLURM_INVALID_SCHEDTYPE_CHANGE),
	  "SchedulerType change requires restart of the slurmctld daemon "
	  "to take effect"					},
	{ ERRTAB_ENTRY(ESLURM_INVALID_SELECTTYPE_CHANGE),
	  "SelectType change requires restart of the slurmctld daemon "
	  "to take effect"					},
	{ ERRTAB_ENTRY(ESLURM_INVALID_SWITCHTYPE_CHANGE),
	  "SwitchType change requires restart of all Slurm daemons and "
	  "jobs to take effect"					},
	{ ERRTAB_ENTRY(ESLURM_FRAGMENTATION),
	  "Immediate execution impossible, "
	  "resources too fragmented for allocation"		},
	{ ERRTAB_ENTRY(ESLURM_NOT_SUPPORTED),
	  "Requested operation not supported on this system"	},
	{ ERRTAB_ENTRY(ESLURM_DISABLED),
	  "Requested operation is presently disabled"		},
	{ ERRTAB_ENTRY(ESLURM_DEPENDENCY),
	  "Job dependency problem"				},
	{ ERRTAB_ENTRY(ESLURM_BATCH_ONLY),
	  "Only batch jobs are accepted or processed"		},
	{ ERRTAB_ENTRY(ESLURM_LICENSES_UNAVAILABLE),
	  "Licenses currently unavailable"			},
	{ ERRTAB_ENTRY(ESLURM_TAKEOVER_NO_HEARTBEAT),
	  "Unable to takeover, heartbeat file is missing"	},
	{ ERRTAB_ENTRY(ESLURM_JOB_HELD),
	  "Job is in held state, pending scheduler release"	},
	{ ERRTAB_ENTRY(ESLURM_INVALID_TASK_MEMORY),
	  "Memory required by task is not available"		},
	{ ERRTAB_ENTRY(ESLURM_INVALID_ACCOUNT),
	  "Invalid account or account/partition combination specified"},
	{ ERRTAB_ENTRY(ESLURM_INVALID_PARENT_ACCOUNT),
	  "Invalid parent account specified"			},
	{ ERRTAB_ENTRY(ESLURM_SAME_PARENT_ACCOUNT),
	  "Account already child of parent account specified"   },
	{ ERRTAB_ENTRY(ESLURM_INVALID_QOS),
	  "Invalid qos specification"				},
	{ ERRTAB_ENTRY(ESLURM_INVALID_WCKEY),
	  "Invalid wckey specification"				},
	{ ERRTAB_ENTRY(ESLURM_INVALID_LICENSES),
	  "Invalid license specification"			},
	{ ERRTAB_ENTRY(ESLURM_NEED_RESTART),
	  "The node configuration changes that were made require restart "
	  "of the slurmctld daemon to take effect"},
	{ ERRTAB_ENTRY(ESLURM_ACCOUNTING_POLICY),
	  "Job violates accounting/QOS policy (job submit limit, user's "
	  "size and/or time limits)"},
	{ ERRTAB_ENTRY(ESLURM_INVALID_TIME_LIMIT),
	  "Requested time limit is invalid (missing or exceeds some limit)"},
	{ ERRTAB_ENTRY(ESLURM_RESERVATION_ACCESS),
	  "Access denied to requested reservation"		},
	{ ERRTAB_ENTRY(ESLURM_RESERVATION_INVALID),
	  "Requested reservation is invalid"			},
	{ ERRTAB_ENTRY(ESLURM_INVALID_TIME_VALUE),
	  "Invalid time specified"				},
	{ ERRTAB_ENTRY(ESLURM_RESERVATION_BUSY),
	  "Requested reservation is in use"			},
	{ ERRTAB_ENTRY(ESLURM_RESERVATION_NOT_USABLE),
	  "Requested reservation not usable now"		},
	{ ERRTAB_ENTRY(ESLURM_RESERVATION_OVERLAP),
	  "Requested reservation overlaps with another reservation"	},
	{ ERRTAB_ENTRY(ESLURM_PORTS_BUSY),
	  "Required ports are in use"				},
	{ ERRTAB_ENTRY(ESLURM_PORTS_INVALID),
	  "Requires more ports than can be reserved"		},
	{ ERRTAB_ENTRY(ESLURM_PROLOG_RUNNING),
	  "PrologSlurmctld is still running"			},
	{ ERRTAB_ENTRY(ESLURM_NO_STEPS),
	  "Job steps can not be run on this cluster"		},
	{ ERRTAB_ENTRY(ESLURM_MISSING_WORK_DIR),
	  "Job cannot be submitted without the current working directory specified." },
	{ ERRTAB_ENTRY(ESLURM_QOS_PREEMPTION_LOOP),
	  "QOS Preemption loop detected"                	},
	{ ERRTAB_ENTRY(ESLURM_NODE_NOT_AVAIL),
	  "Required node not available (down, drained or reserved)"},
	{ ERRTAB_ENTRY(ESLURM_INVALID_CPU_COUNT),
	  "CPU count specification invalid"             	},
	{ ERRTAB_ENTRY(ESLURM_PARTITION_NOT_AVAIL),
	  "Required partition not available (inactive or drain)"},
	{ ERRTAB_ENTRY(ESLURM_CIRCULAR_DEPENDENCY),
	  "Circular job dependency"				},
	{ ERRTAB_ENTRY(ESLURM_INVALID_GRES),
	  "Invalid generic resource (gres) specification"	},
	{ ERRTAB_ENTRY(ESLURM_JOB_NOT_PENDING),
	  "Job is no longer pending execution"			},
	{ ERRTAB_ENTRY(ESLURM_QOS_THRES),
	  "Requested account has breached requested QOS usage threshold"},
	{ ERRTAB_ENTRY(ESLURM_PARTITION_IN_USE),
	  "Partition is in use"					},
	{ ERRTAB_ENTRY(ESLURM_STEP_LIMIT),
	  "Step limit reached for this job"			},
	{ ERRTAB_ENTRY(ESLURM_JOB_SUSPENDED),
	  "Job is current suspended, requested operation disabled"	},
	{ ERRTAB_ENTRY(ESLURM_CAN_NOT_START_IMMEDIATELY),
	  "Job can not start immediately"			},
	{ ERRTAB_ENTRY(ESLURM_INTERCONNECT_BUSY),
	  "Switch resources currently not available"		},
	{ ERRTAB_ENTRY(ESLURM_RESERVATION_EMPTY),
	  "Reservation request lacks users, groups or accounts"		},
	{ ERRTAB_ENTRY(ESLURM_INVALID_ARRAY),
	  "Invalid job array specification"			},
	{ ERRTAB_ENTRY(ESLURM_RESERVATION_NAME_DUP),
	  "Duplicate reservation name"				},
	{ ERRTAB_ENTRY(ESLURM_JOB_STARTED),
	  "Job has already started"				},
	{ ERRTAB_ENTRY(ESLURM_JOB_FINISHED),
	  "Job has already finished"				},
	{ ERRTAB_ENTRY(ESLURM_JOB_NOT_RUNNING),
	  "Job is not running"},
	{ ERRTAB_ENTRY(ESLURM_JOB_NOT_PENDING_NOR_RUNNING),
	  "Job is not pending nor running"			},
	{ ERRTAB_ENTRY(ESLURM_JOB_NOT_SUSPENDED),
	  "Job is not suspended"				},
	{ ERRTAB_ENTRY(ESLURM_JOB_NOT_FINISHED),
	  "Job is not finished"					},
	{ ERRTAB_ENTRY(ESLURM_TRIGGER_DUP),
	  "Duplicate event trigger"				},
	{ ERRTAB_ENTRY(ESLURM_INTERNAL),
	  "Slurm internal error, contact system administrator"	},
	{ ERRTAB_ENTRY(ESLURM_INVALID_BURST_BUFFER_CHANGE),
	  "BurstBufferType change requires restart of slurmctld daemon "
	  "to take effect"},
	{ ERRTAB_ENTRY(ESLURM_BURST_BUFFER_PERMISSION),
	  "Burst Buffer permission denied"			},
	{ ERRTAB_ENTRY(ESLURM_BURST_BUFFER_LIMIT),
	  "Burst Buffer resource limit exceeded"		},
	{ ERRTAB_ENTRY(ESLURM_INVALID_BURST_BUFFER_REQUEST),
	  "Burst Buffer request invalid"			},
	{ ERRTAB_ENTRY(ESLURM_PRIO_RESET_FAIL),
	  "Changes to job priority are not persistent, change nice instead" },
	{ ERRTAB_ENTRY(ESLURM_CANNOT_MODIFY_CRON_JOB),
	  "Cannot modify scrontab jobs through scontrol"	},
	{ ERRTAB_ENTRY(ESLURM_INVALID_JOB_CONTAINER_CHANGE),
	  "JobContainerType change requires restart of all Slurm daemons and commands to take effect" },
	{ ERRTAB_ENTRY(ESLURM_CANNOT_CANCEL_CRON_JOB),
	  "Cannot cancel scrontab jobs without --cron flag."	},
	{ ERRTAB_ENTRY(ESLURM_INVALID_MCS_LABEL),
	  "Invalid mcs_label specified"				},
	{ ERRTAB_ENTRY(ESLURM_BURST_BUFFER_WAIT),
	  "Waiting for burst buffer"				},
	{ ERRTAB_ENTRY(ESLURM_PARTITION_DOWN),
	  "Partition in DOWN state"				},
	{ ERRTAB_ENTRY(ESLURM_DUPLICATE_GRES),
	  "Duplicate generic resource (gres) specification"	},
	{ ERRTAB_ENTRY(ESLURM_RSV_ALREADY_STARTED),
	  "Reservation already started"				},
	{ ERRTAB_ENTRY(ESLURM_SUBMISSIONS_DISABLED),
	  "System submissions disabled"				},
	{ ERRTAB_ENTRY(ESLURM_NOT_HET_JOB),
	  "Job not heterogeneous job"				},
	{ ERRTAB_ENTRY(ESLURM_NOT_HET_JOB_LEADER),
	  "Job not heterogeneous job leader"			},
	{ ERRTAB_ENTRY(ESLURM_NOT_WHOLE_HET_JOB),
	  "Operation not permitted on individual component of heterogeneous job" },
	{ ERRTAB_ENTRY(ESLURM_CORE_RESERVATION_UPDATE),
	  "Core-based reservation can not be updated"		},
	{ ERRTAB_ENTRY(ESLURM_DUPLICATE_STEP_ID),
	  "Duplicate job step id"				},
	{ ERRTAB_ENTRY(ESLURM_X11_NOT_AVAIL),
	  "X11 forwarding not available"			},
	{ ERRTAB_ENTRY(ESLURM_GROUP_ID_MISSING),
	  "Invalid group id"					},
	{ ERRTAB_ENTRY(ESLURM_BATCH_CONSTRAINT),
	  "Job --batch option is invalid or not a subset of --constraint" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_TRES),
	  "Invalid Trackable RESource (TRES) specification"	},
	{ ERRTAB_ENTRY(ESLURM_INVALID_TRES_BILLING_WEIGHTS),
	  "Invalid TRESBillingWeights specification"            },
	{ ERRTAB_ENTRY(ESLURM_INVALID_JOB_DEFAULTS),
	  "Invalid JobDefaults specification"			},
	{ ERRTAB_ENTRY(ESLURM_RESERVATION_MAINT),
	  "Job can not start due to maintenance reservation."	},
	{ ERRTAB_ENTRY(ESLURM_INVALID_GRES_TYPE),
	  "Invalid GRES specification (with and without type identification)" },
	{ ERRTAB_ENTRY(ESLURM_REBOOT_IN_PROGRESS),
	  "Reboot already in progress" },
	{ ERRTAB_ENTRY(ESLURM_MULTI_KNL_CONSTRAINT),
	  "Multiple KNL NUMA and/or MCDRAM constraints require use of a heterogeneous job" },
	{ ERRTAB_ENTRY(ESLURM_UNSUPPORTED_GRES),
	  "Requested GRES option unsupported by configured SelectType plugin" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_NICE),
	  "Invalid --nice value"				},
	{ ERRTAB_ENTRY(ESLURM_INVALID_TIME_MIN_LIMIT),
	  "Invalid time-min specification (exceeds job's time or other limits)"},
	{ ERRTAB_ENTRY(ESLURM_DEFER),
	  "Immediate execution impossible. "
	  "Individual job submission scheduling attempts deferred"},
	{ ERRTAB_ENTRY(ESLURM_CONFIGLESS_DISABLED),
	  "ConfigLess mode is disabled in slurm configuration."	},
	{ ERRTAB_ENTRY(ESLURM_ENVIRONMENT_MISSING),
	  "Environment is missing in job"			},
	{ ERRTAB_ENTRY(ESLURM_RESERVATION_NO_SKIP),
	  "Reservation given is not skipable, try deleting instead"},
	{ ERRTAB_ENTRY(ESLURM_RESERVATION_USER_GROUP),
	  "Reservations can't have users and groups specified, only one or the other"},
	{ ERRTAB_ENTRY(ESLURM_PARTITION_ASSOC),
	  "Multiple partition job request not supported when a partition is set in the association" },
	{ ERRTAB_ENTRY(ESLURM_IN_STANDBY_USE_BACKUP),
	  "Controller is in standby mode, try a different controller"},
	{ ERRTAB_ENTRY(ESLURM_BAD_THREAD_PER_CORE),
	  "Cannot request more threads per core than the job allocation" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_PREFER),
	  "Invalid preferred feature specification"		},
	{ ERRTAB_ENTRY(ESLURM_INSUFFICIENT_GRES),
	  "Insufficient GRES available in allocation"		},
	{ ERRTAB_ENTRY(ESLURM_INVALID_CONTAINER_ID),
	  "Invalid container id specified"			},
	{ ERRTAB_ENTRY(ESLURM_EMPTY_JOB_ID),
	  "JobID must not be an empty string" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_JOB_ID_ZERO),
	  "JobID can not be zero" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_JOB_ID_NEGATIVE),
	  "JobID can not be a negative number" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_JOB_ID_TOO_LARGE),
	  "JobID larger than acceptable range" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_JOB_ID_NON_NUMERIC),
	  "JobID includes unexpected non-numeric characters" },
	{ ERRTAB_ENTRY(ESLURM_EMPTY_JOB_ARRAY_ID),
	  "Job Array ID must not be an empty string" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_JOB_ARRAY_ID_NEGATIVE),
	  "Job Array ID can not be a negative number" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_JOB_ARRAY_ID_TOO_LARGE),
	  "Job Array ID larger than acceptable range" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_JOB_ARRAY_ID_NON_NUMERIC),
	  "Job Array ID includes unexpected non-numeric characters" },
	{ ERRTAB_ENTRY(ESLURM_EMPTY_HET_JOB_COMP),
	  "HetJob component must not be an empty string" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_HET_JOB_COMP_NEGATIVE),
	  "HetJob component can not be a negative number" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_HET_JOB_COMP_TOO_LARGE),
	  "HetJob component larger than acceptable range" },
	{ ERRTAB_ENTRY(ESLURM_EMPTY_STEP_ID),
	  "StepID must not be an empty string" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_STEP_ID_NEGATIVE),
	  "StepID can not be a negative number" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_STEP_ID_TOO_LARGE),
	  "StepID larger than acceptable range" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_STEP_ID_NON_NUMERIC),
	  "StepID includes unexpected non-numeric characters" },
	{ ERRTAB_ENTRY(ESLURM_EMPTY_HET_STEP),
	  "HetStep component must not be an empty string" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_HET_STEP_ZERO),
	  "HetStep component can not be zero" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_HET_STEP_NEGATIVE),
	  "HetStep component can not be a negative number" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_HET_STEP_TOO_LARGE),
	  "HetStep component larger than acceptable range" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_HET_STEP_NON_NUMERIC),
	  "HetStep component includes unexpected non-numeric characters" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_HET_STEP_JOB),
	  "HetJob can not Het step id" },
	{ ERRTAB_ENTRY(ESLURM_JOB_TIMEOUT_KILLED),
	  "Job killed due hitting max wall clock limit" },
	{ ERRTAB_ENTRY(ESLURM_JOB_NODE_FAIL_KILLED),
	  "Job killed due node failure" },
	{ ERRTAB_ENTRY(ESLURM_EMPTY_LIST),
	  "Empty list" },
	{ ERRTAB_ENTRY(ESLURM_GROUP_ID_INVALID),
	  "Invalid group ID" },
	{ ERRTAB_ENTRY(ESLURM_GROUP_ID_UNKNOWN),
	  "Unable to resolve group ID to group name" },
	{ ERRTAB_ENTRY(ESLURM_USER_ID_INVALID),
	  "Invalid user ID" },
	{ ERRTAB_ENTRY(ESLURM_USER_ID_UNKNOWN),
	  "Unable to resolve user ID to user name" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_ASSOC),
	  "Invalid or unknown association" },
	{ ERRTAB_ENTRY(ESLURM_NODE_ALREADY_EXISTS),
	  "Node already exists in the node table" },
	{ ERRTAB_ENTRY(ESLURM_NODE_TABLE_FULL),
	  "Unable to add node, node table is full" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_RELATIVE_QOS),
	  "Invalid QOS specification, relative QOS can only be used in a single partition per cluster." },
	{ ERRTAB_ENTRY(ESLURM_INVALID_EXTRA),
	  "Invalid extra constraints specification" },
	{ ERRTAB_ENTRY(ESLURM_JOB_SIGNAL_FAILED),
	  "Cannot signal job" },
	{ ERRTAB_ENTRY(ESLURM_SIGNAL_JOBS_INVALID),
	  "Invalid signal jobs request, at least one job id or filter is required." },
	{ ERRTAB_ENTRY(ESLURM_RES_CORES_PER_GPU_UNIQUE),
	  "RestrictedCoresPerGPU: Not enough unique cores per GPU" },
	{ ERRTAB_ENTRY(ESLURM_RES_CORES_PER_GPU_TOPO),
	  "RestrictedCoresPerGPU: Missing core topology for GPUs" },
	{ ERRTAB_ENTRY(ESLURM_RES_CORES_PER_GPU_NO),
	  "RestrictedCoresPerGPU: No GPUs configured on node" },
	{ ERRTAB_ENTRY(ESLURM_MAX_POWERED_NODES),
	  "Max powered up nodes reached" },
	{ ERRTAB_ENTRY(ESLURM_REQUESTED_TOPO_CONFIG_UNAVAILABLE),
	  "Requested topology configuration is not available" },
	{ ERRTAB_ENTRY(ESLURM_PREEMPTION_REQUIRED),
	  "Preemption is required but is disabled on this system" },
	{ ERRTAB_ENTRY(ESLURM_INVALID_NODE_STATE_TRANSITION),
	  "Invalid node state transition"			},
	{ ERRTAB_ENTRY(ESLURM_INVALID_JOB_STATE),
	  "Invalid job state" },

	/* SPANK errors */
	{ ERRTAB_ENTRY(ESPANK_ERROR),
	  "Generic error"					},
	{ ERRTAB_ENTRY(ESPANK_BAD_ARG),
	  "Bad argument"					},
	{ ERRTAB_ENTRY(ESPANK_NOT_TASK),
	  "Not in task context"					},
	{ ERRTAB_ENTRY(ESPANK_ENV_EXISTS),
	  "Environment variable exists"				},
	{ ERRTAB_ENTRY(ESPANK_ENV_NOEXIST),
	  "No such environment variable"			},
	{ ERRTAB_ENTRY(ESPANK_NOSPACE),
	  "Buffer too small"					},
	{ ERRTAB_ENTRY(ESPANK_NOT_REMOTE),
	  "Valid only in remote context"			},
	{ ERRTAB_ENTRY(ESPANK_NOEXIST),
	  "Id/PID does not exist on this node"			},
	{ ERRTAB_ENTRY(ESPANK_NOT_EXECD),
	  "Lookup by PID requested, but no tasks running"	},
	{ ERRTAB_ENTRY(ESPANK_NOT_AVAIL),
	  "Item not available from this callback"		},
	{ ERRTAB_ENTRY(ESPANK_NOT_LOCAL),
	  "Valid only in local or allocator context"		},
	{ ERRTAB_ENTRY(ESPANK_NODE_FAILURE),
	  "Spank plugin failure, node failed" },
	{ ERRTAB_ENTRY(ESPANK_JOB_FAILURE),
	  "Spank plugin failure, job failed" },

	/* slurmd error codes */
	{ ERRTAB_ENTRY(ESLURMD_KILL_TASK_FAILED),
	  "Kill task failed"					},
	{ ERRTAB_ENTRY(ESLURMD_INVALID_ACCT_FREQ),
	  "Invalid accounting frequency requested"		},
	{ ERRTAB_ENTRY(ESLURMD_INVALID_JOB_CREDENTIAL),
	  "Invalid job credential"				},
	{ ERRTAB_ENTRY(ESLURMD_CREDENTIAL_REVOKED),
	  "Job credential revoked"                              },
	{ ERRTAB_ENTRY(ESLURMD_CREDENTIAL_EXPIRED),
	  "Job credential expired"                              },
	{ ERRTAB_ENTRY(ESLURMD_CREDENTIAL_REPLAYED),
	  "Job credential replayed"                             },
	{ ERRTAB_ENTRY(ESLURMD_CREATE_BATCH_DIR_ERROR),
	  "Slurmd could not create a batch directory or file"	},
	{ ERRTAB_ENTRY(ESLURMD_SETUP_ENVIRONMENT_ERROR),
	  "Slurmd could not set up environment for batch job"	},
	{ ERRTAB_ENTRY(ESLURMD_SET_UID_OR_GID_ERROR),
	  "Slurmd could not set UID or GID"			},
	{ ERRTAB_ENTRY(ESLURMD_EXECVE_FAILED),
	  "Slurmd could not execve job"				},
	{ ERRTAB_ENTRY(ESLURMD_IO_ERROR),
	  "Slurmd could not connect IO"			        },
	{ ERRTAB_ENTRY(ESLURMD_PROLOG_FAILED),
	  "Job prolog failed"			        	},
	{ ERRTAB_ENTRY(ESLURMD_EPILOG_FAILED),
	  "Job epilog failed"			        	},
	{ ERRTAB_ENTRY(ESLURMD_TOOMANYSTEPS),
	  "Too many job steps on node"		        	},
	{ ERRTAB_ENTRY(ESLURMD_STEP_EXISTS),
	  "Job step already exists"		        	},
	{ ERRTAB_ENTRY(ESLURMD_STEP_NOTRUNNING),
	  "Job step not running"	        	        },
	{ ERRTAB_ENTRY(ESLURMD_STEP_SUSPENDED),
	  "Job step is suspended"                               },
	{ ERRTAB_ENTRY(ESLURMD_STEP_NOTSUSPENDED),
	  "Job step is not currently suspended"                 },
	{ ERRTAB_ENTRY(ESLURMD_INVALID_SOCKET_NAME_LEN),
	  "Unix socket name exceeded maximum length"		},
	{ ERRTAB_ENTRY(ESLURMD_CONTAINER_RUNTIME_INVALID),
	  "Container runtime not configured or invalid"		},
	{ ERRTAB_ENTRY(ESLURMD_CPU_BIND_ERROR),
	  "Unable to satisfy cpu bind request"			},
	{ ERRTAB_ENTRY(ESLURMD_CPU_LAYOUT_ERROR),
	  "Unable to layout tasks on given cpus"		},
	{ ERRTAB_ENTRY(ESLURMD_STEPD_PROXY_FAILED),
	  "Unable to proxy slurmstepd message"			},

	/* socket specific Slurm communications error */

	{ ERRTAB_ENTRY(ESLURM_PROTOCOL_INCOMPLETE_PACKET),
	  "Header lengths are longer than data received"	},
	{ ERRTAB_ENTRY(SLURM_PROTOCOL_SOCKET_IMPL_TIMEOUT),
	  "Socket timed out on send/recv operation"		},
	{ ERRTAB_ENTRY(SLURM_PROTOCOL_SOCKET_ZERO_BYTES_SENT),
	  "Zero Bytes were transmitted or received"		},

	/* slurm_auth errors */

	{ ERRTAB_ENTRY(ESLURM_AUTH_CRED_INVALID),
	  "Invalid authentication credential"			},
	{ ERRTAB_ENTRY(ESLURM_AUTH_EXPIRED),
	  "Authentication credential expired"			},
	{ ERRTAB_ENTRY(ESLURM_AUTH_BADARG),
	  "Bad argument to plugin function"			},
	{ ERRTAB_ENTRY(ESLURM_AUTH_UNPACK),
	  "Cannot unpack credential"				},
	{ ERRTAB_ENTRY(ESLURM_AUTH_SKIP),
	  "Authentication does not apply to request"		},
	{ ERRTAB_ENTRY(ESLURM_AUTH_UNABLE_TO_GENERATE_TOKEN),
	  "Token Generation failed."				},

	/* accounting errors */
	{ ERRTAB_ENTRY(ESLURM_DB_CONNECTION),
	  "Unable to connect to database"			},
	{ ERRTAB_ENTRY(ESLURM_JOBS_RUNNING_ON_ASSOC),
	  "Job(s) active, cancel job(s) before remove"		},
	{ ERRTAB_ENTRY(ESLURM_CLUSTER_DELETED),
	  "Cluster deleted, commit/rollback immediately"        },
	{ ERRTAB_ENTRY(ESLURM_ONE_CHANGE),
	  "Can only change one at a time"                       },
	{ ERRTAB_ENTRY(ESLURM_BAD_NAME),
	  "Unacceptable name given. (No '.' in name allowed)"   },
	{ ERRTAB_ENTRY(ESLURM_OVER_ALLOCATE),
	  "You can not allocate more than 100% of a resource"	},
	{ ERRTAB_ENTRY(ESLURM_RESULT_TOO_LARGE),
	  "Query result exceeds size limit"			},
	{ ERRTAB_ENTRY(ESLURM_DB_QUERY_TOO_WIDE),
	  "Too wide of a date range in query"			},
	{ ERRTAB_ENTRY(ESLURM_DB_CONNECTION_INVALID),
	  "Database connection reference is invalid"		},
	{ ERRTAB_ENTRY(ESLURM_NO_REMOVE_DEFAULT_ACCOUNT),
	  "You can not remove the default account of a user"	},
	{ ERRTAB_ENTRY(ESLURM_BAD_SQL),
	  "There is something internally wrong with the SQL needed for this. Please consult the slurmdbd log for more info."                    },
	{ ERRTAB_ENTRY(ESLURM_NO_REMOVE_DEFAULT_QOS),
	  "This request would make it so some associations would not have access to their default qos."                                         },
	{ ERRTAB_ENTRY(ESLURM_COORD_NO_INCREASE_JOB_LIMIT),
	  "Coordinators can not increase job limits beyond the parent ones" },
	{ ERRTAB_ENTRY(ESLURM_NO_RPC_STATS), "No RPC stats are available" },

	/* Federation Errors */
	{ ERRTAB_ENTRY(ESLURM_FED_CLUSTER_MAX_CNT),
	  "Too many clusters in federation"			},
	{ ERRTAB_ENTRY(ESLURM_FED_CLUSTER_MULTIPLE_ASSIGNMENT),
	  "Clusters can only be assigned to one federation" 	},
	{ ERRTAB_ENTRY(ESLURM_INVALID_CLUSTER_FEATURE),
	  "Invalid cluster feature specification"		},
	{ ERRTAB_ENTRY(ESLURM_JOB_NOT_FEDERATED),
	  "Not a valid federated job"				},
	{ ERRTAB_ENTRY(ESLURM_INVALID_CLUSTER_NAME),
	  "Invalid cluster name"				},
	{ ERRTAB_ENTRY(ESLURM_FED_JOB_LOCK),
	  "Job locked by another sibling"			},
	{ ERRTAB_ENTRY(ESLURM_FED_NO_VALID_CLUSTERS),
	  "No eligible clusters for federated job"		},

	/* Lua wrapper errors */
	{ ERRTAB_ENTRY(ESLURM_LUA_INVALID_STATE),
	  "Invalid or NULL Lua state pointer" },
	{ ERRTAB_ENTRY(ESLURM_LUA_INVALID_SYNTAX),
	  "Lua script loading failed due to invalid syntax" },
	{ ERRTAB_ENTRY(ESLURM_LUA_FUNC_NOT_FOUND),
	  "Requested Lua function not found" },
	{ ERRTAB_ENTRY(ESLURM_LUA_FUNC_INVALID_RC),
	  "Lua function returned nil or table instead of numeric result" },
	{ ERRTAB_ENTRY(ESLURM_LUA_FUNC_FAILED),
	  "Lua function execution failed for unknown reasons" },
	{ ERRTAB_ENTRY(ESLURM_LUA_FUNC_FAILED_RUNTIME_ERROR),
	  "Lua function execution failed due to runtime error" },
	{ ERRTAB_ENTRY(ESLURM_LUA_FUNC_FAILED_ENOMEM),
	  "Lua function execution failed due to memory allocation failure. Either not enough memory for Lua script's variables or memory allocation request for a variable was way too large." },
	{ ERRTAB_ENTRY(ESLURM_LUA_FUNC_FAILED_GARBAGE_COLLECTOR),
	  "Lua function execution failed due to unknown failure in Lua's garbage collector" },
	{ ERRTAB_ENTRY(ESLURM_LUA_INVALID_CONVERSION_TYPE),
	  "Unknown or unparsable Lua type found at top of Lua stack" },

	/* plugin and custom errors */
	{ ERRTAB_ENTRY(ESLURM_MISSING_TIME_LIMIT),
	  "Time limit specification required, but not provided"	},
	{ ERRTAB_ENTRY(ESLURM_INVALID_KNL),
	  "Invalid KNL configuration (MCDRAM or NUMA option)"	},
	{ ERRTAB_ENTRY(ESLURM_PLUGIN_INVALID),
	  "Plugin has invalid format or unable to be loaded"	},
	{ ERRTAB_ENTRY(ESLURM_PLUGIN_INCOMPLETE),
	  "Plugin missing required symbol or function"		},
	{ ERRTAB_ENTRY(ESLURM_PLUGIN_NOT_LOADED),
	  "Required plugin type not loaded or initialized"	},
	{ ERRTAB_ENTRY(ESLURM_PLUGIN_NOTFOUND),
	  "Plugin file not found"				},
	{ ERRTAB_ENTRY(ESLURM_PLUGIN_ACCESS_ERROR),
	  "Plugin access denied"				},
	{ ERRTAB_ENTRY(ESLURM_PLUGIN_DLOPEN_FAILED),
	  "Dlopen of plugin file failed"			},
	{ ERRTAB_ENTRY(ESLURM_PLUGIN_INIT_FAILED),
	  "Plugin init() callback failed"			},
	{ ERRTAB_ENTRY(ESLURM_PLUGIN_MISSING_NAME),
	  "Plugin name/type/version symbol missing"		},
	{ ERRTAB_ENTRY(ESLURM_PLUGIN_BAD_VERSION),
	  "Incompatible plugin version"				},

	/* REST errors */
	{ ERRTAB_ENTRY(ESLURM_REST_INVALID_QUERY),
	  "Query empty or not RFC7320 compliant"},
	{ ERRTAB_ENTRY(ESLURM_REST_FAIL_PARSING),
	  "Failure during parsing"},
	{ ERRTAB_ENTRY(ESLURM_REST_INVALID_JOBS_DESC),
	  "Jobs description entry not found, empty or not dictionary or list"},
	{ ERRTAB_ENTRY(ESLURM_REST_EMPTY_RESULT),
	  "Nothing found with query"},
	{ ERRTAB_ENTRY(ESLURM_REST_MISSING_UID),
	  "Missing UNIX user in the system"},
	{ ERRTAB_ENTRY(ESLURM_REST_MISSING_GID),
	  "Missing UNIX group in the system"},

	/* data_t errors */
	{ ERRTAB_ENTRY(ESLURM_DATA_PATH_NOT_FOUND),
	  "Unable to resolve path"},
	{ ERRTAB_ENTRY(ESLURM_DATA_PTR_NULL),
	  "Data pointer is NULL"},
	{ ERRTAB_ENTRY(ESLURM_DATA_CONV_FAILED),
	  "Unable to convert Data type"},
	{ ERRTAB_ENTRY(ESLURM_DATA_REGEX_COMPILE),
	  "Unable to compile regex"},
	{ ERRTAB_ENTRY(ESLURM_DATA_UNKNOWN_MIME_TYPE),
	  "MIME type is unknown to any loaded plugins"},
	{ ERRTAB_ENTRY(ESLURM_DATA_TOO_LARGE),
	  "Data too large to handle"},
	{ ERRTAB_ENTRY(ESLURM_DATA_FLAGS_INVALID_TYPE),
	  "Data parser expects flags to be a list"},
	{ ERRTAB_ENTRY(ESLURM_DATA_FLAGS_INVALID),
	  "Data parser unable to parse invalid flag"},
	{ ERRTAB_ENTRY(ESLURM_DATA_EXPECTED_LIST),
	  "Data parser expected a list"},
	{ ERRTAB_ENTRY(ESLURM_DATA_EXPECTED_DICT),
	  "Data parser expected a dictionary or object"},
	{ ERRTAB_ENTRY(ESLURM_DATA_AMBIGUOUS_MODIFY),
	  "Request matched more than one object to modify. Modifications must only apply to a single object. Try adding more properties to make update match a unique object."},
	{ ERRTAB_ENTRY(ESLURM_DATA_AMBIGUOUS_QUERY),
	  "Request matched more than one object to query. Request is limited to query of a single matching object."},
	{ ERRTAB_ENTRY(ESLURM_DATA_PARSE_NOTHING),
	  "Request to parse empty string rejected"},
	{ ERRTAB_ENTRY(ESLURM_DATA_INVALID_PARSER),
	  "Invalid parser requested"},
	{ ERRTAB_ENTRY(ESLURM_DATA_PARSING_DEPTH),
	  "Parsing tree too deep. Possible cyclic parsing detected"},
	{ ERRTAB_ENTRY(ESLURM_DATA_PARSER_INVALID_STATE),
	  "Parser went into an invalid state. Possible library issue."},

	/* container  errors */
	{ ERRTAB_ENTRY(ESLURM_CONTAINER_NOT_CONFIGURED),
	  "Container support is not configured"},

	/* url errors */
	{ ERRTAB_ENTRY(ESLURM_URL_UNKNOWN_SCHEME),
	  "Unknown URL scheme"},
	{ ERRTAB_ENTRY(ESLURM_URL_EMPTY),
	  "URL string is empty"},
	{ ERRTAB_ENTRY(ESLURM_URL_NON_NULL_TERMINATOR),
	  "Invalid non-NULL terminated URL" },
	{ ERRTAB_ENTRY(ESLURM_URL_INVALID_FORMATING),
	  "Invalid format for URL format" },
	{ ERRTAB_ENTRY(ESLURM_URL_INVALID_SCHEME),
	  "Invalid or unknown URL scheme" },
	{ ERRTAB_ENTRY(ESLURM_URL_UNSUPPORTED_SCHEME),
	  "URL scheme not supported" },
	{ ERRTAB_ENTRY(ESLURM_URL_INVALID_HOST),
	  "Invalid or unknown URL host" },
	{ ERRTAB_ENTRY(ESLURM_URL_INVALID_PORT),
	  "Invalid or unknown URL port" },
	{ ERRTAB_ENTRY(ESLURM_URL_INVALID_PATH),
	  "Invalid or unknown URL path" },
	{ ERRTAB_ENTRY(ESLURM_URL_INVALID_QUERY),
	  "Invalid or unknown URL query" },
	{ ERRTAB_ENTRY(ESLURM_URL_INVALID_FRAGMENT),
	  "Invalid or unknown URL fragment" },
	{ ERRTAB_ENTRY(ESLURM_URL_UNSUPPORTED_FORMAT),
	  "URL format not supported" },

	/* http errors */
	{ ERRTAB_ENTRY(ESLURM_HTTP_EMPTY_HEADER),
	  "Invalid empty HTTP header" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_PARSING_FAILURE),
	  "Unspecified error during HTTP parsing" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_UNEXPECTED_URL),
	  "Unexpected duplicate URL" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_INVALID_STATUS_CODE),
	  "Invalid HTTP status code" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_INVALID_METHOD),
	  "Invalid HTTP method" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_MISSING_LF),
	  "Expected LF character but not found" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_INVALID_CHARACTER),
	  "Unexpected character added or missing in HTTP" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_INVALID_CONTENT_LENGTH),
	  "Unexpected character or unparsable number in HTTP Content-Length header" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_INVALID_TRANSFER_ENCODING),
	  "Invalid HTTP Tranfser-Encoding header" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_UNSUPPORTED_CHUNK_ENCODING),
	  "HTTP Chunked Transfer-Encoding not supported" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_UNEXPECTED_REQUEST),
	  "Received unexpected HTTP Request" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_UNSUPPORTED_VERSION),
	  "Only HTTP version 1.1 requests are supported" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_UNSUPPORTED_UPGRADE),
	  "HTTP protocol upgrading is not supported." },
	{ ERRTAB_ENTRY(ESLURM_HTTP_INVALID_CONTENT_ENCODING),
	  "Invalid or unsupported HTTP Content-Encoding header" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_UNSUPPORTED_EXPECT),
	  "Invalid or unsupported HTTP Content-Encoding header" },
	{ ERRTAB_ENTRY(ESLURM_HTTP_UNSUPPORTED_KEEP_ALIVE),
	  "Invalid or unsupported HTTP Keep-Alive header" },

	/* TLS errors */
	{ ERRTAB_ENTRY(ESLURM_TLS_REQUIRED),
	  "TLS missing but required for connection" },
};

unsigned int slurm_errtab_size = sizeof(slurm_errtab) / sizeof(slurm_errtab_t);

/*
 * Linear search through table of errno values and strings,
 * returns NULL on error, string on success.
 */
static char *_lookup_slurm_api_errtab(int errnum)
{
	char *res = NULL;
	int i;

	for (i = 0; i < slurm_errtab_size; i++) {
		if (slurm_errtab[i].xe_number == errnum) {
			res = slurm_errtab[i].xe_message;
			break;
		}
	}

	return res;
}

/*
 * Return string associated with error (Slurm or system).
 * Always returns a valid string (because strerror always does).
 */
char *slurm_strerror(int errnum)
{
	char *res = _lookup_slurm_api_errtab(errnum);
	if (res)
		return res;
	else if (errnum > 0)
		return strerror(errnum);
	else
		return "Unknown negative error number";
}

/*
 * Print "message: error description" on stderr for current errno value.
 */
void slurm_perror(const char *msg)
{
	fprintf(stderr, "%s: %s\n", msg, slurm_strerror(errno));
}