uint32_t
GetOptionAndValue(
const char* pszOptArg,
PTDNF_CMD_OPT* ppCmdOpt
)
{
uint32_t dwError = 0;
const char* EQUAL_SIGN = "=";
const char* pszIndex = NULL;
PTDNF_CMD_OPT pCmdOpt = NULL;
int nEqualsPos = -1;
if(IsNullOrEmptyString(pszOptArg) || !ppCmdOpt)
{
dwError = ERROR_TDNF_CLI_INVALID_ARGUMENT;
BAIL_ON_CLI_ERROR(dwError);
}
pszIndex = strstr(pszOptArg, EQUAL_SIGN);
if(!pszIndex)
{
dwError = ERROR_TDNF_CLI_SETOPT_NO_EQUALS;
BAIL_ON_CLI_ERROR(dwError);
}
dwError = TDNFAllocateMemory(1, sizeof(TDNF_CMD_OPT), (void**)&pCmdOpt);
BAIL_ON_CLI_ERROR(dwError);
dwError = TDNFAllocateString(pszOptArg, &pCmdOpt->pszOptName);
BAIL_ON_CLI_ERROR(dwError);
nEqualsPos = pszIndex - pszOptArg;
pCmdOpt->pszOptName[nEqualsPos] = '\0';
dwError = TDNFAllocateString(pszOptArg+nEqualsPos+1, &pCmdOpt->pszOptValue);
BAIL_ON_CLI_ERROR(dwError);
*ppCmdOpt = pCmdOpt;
cleanup:
return dwError;
error:
if(ppCmdOpt)
{
*ppCmdOpt = NULL;
}
if(pCmdOpt)
{
TDNFFreeCmdOpt(pCmdOpt);
}
goto cleanup;
}
uint32_t
TDNFCliGetErrorString(
uint32_t dwErrorCode,
char** ppszError
)
{
uint32_t dwError = 0;
char* pszError = NULL;
int i = 0;
int nCount = 0;
TDNF_ERROR_DESC arErrorDesc[] = TDNF_CLI_ERROR_TABLE;
nCount = sizeof(arErrorDesc)/sizeof(arErrorDesc[0]);
for(i = 0; i < nCount; i++)
{
if (dwErrorCode == arErrorDesc[i].nCode)
{
dwError = TDNFAllocateString(arErrorDesc[i].pszDesc, &pszError);
BAIL_ON_CLI_ERROR(dwError);
break;
}
}
*ppszError = pszError;
cleanup:
return dwError;
error:
TDNF_CLI_SAFE_FREE_MEMORY(pszError);
goto cleanup;
}
uint32_t
TDNFCloneCmdArgs(
PTDNF_CMD_ARGS pCmdArgsIn,
PTDNF_CMD_ARGS* ppCmdArgs
)
{
uint32_t dwError = 0;
int nIndex = 0;
PTDNF_CMD_ARGS pCmdArgs = NULL;
dwError = TDNFAllocateMemory(
sizeof(TDNF_CMD_ARGS),
(void**)&pCmdArgs);
BAIL_ON_TDNF_ERROR(dwError);
pCmdArgs->nAllowErasing = pCmdArgsIn->nAllowErasing;
pCmdArgs->nAssumeNo = pCmdArgsIn->nAssumeNo;
pCmdArgs->nAssumeYes = pCmdArgsIn->nAssumeYes;
pCmdArgs->nBest = pCmdArgsIn->nBest;
pCmdArgs->nCacheOnly = pCmdArgsIn->nCacheOnly;
pCmdArgs->nDebugSolver = pCmdArgsIn->nDebugSolver;
pCmdArgs->nNoGPGCheck = pCmdArgsIn->nNoGPGCheck;
pCmdArgs->nRefresh = pCmdArgsIn->nRefresh;
pCmdArgs->nRpmVerbosity = pCmdArgsIn->nRpmVerbosity;
pCmdArgs->nShowDuplicates= pCmdArgsIn->nShowDuplicates;
pCmdArgs->nShowHelp = pCmdArgsIn->nShowHelp;
pCmdArgs->nShowVersion = pCmdArgsIn->nShowVersion;
pCmdArgs->nVerbose = pCmdArgsIn->nVerbose;
pCmdArgs->nIPv4 = pCmdArgsIn->nIPv4;
pCmdArgs->nIPv6 = pCmdArgsIn->nIPv6;
pCmdArgs->nCmdCount = pCmdArgsIn->nCmdCount;
dwError = TDNFAllocateMemory(
pCmdArgs->nCmdCount * sizeof(char*),
(void**)&pCmdArgs->ppszCmds
);
BAIL_ON_TDNF_ERROR(dwError);
for(nIndex = 0; nIndex < pCmdArgs->nCmdCount; ++nIndex)
{
dwError = TDNFAllocateString(
pCmdArgsIn->ppszCmds[nIndex],
&pCmdArgs->ppszCmds[nIndex]);
BAIL_ON_TDNF_ERROR(dwError);
}
*ppCmdArgs = pCmdArgs;
cleanup:
return dwError;
error:
if(ppCmdArgs)
{
*ppCmdArgs = NULL;
}
TDNFFreeCmdArgs(pCmdArgs);
goto cleanup;
}
uint32_t
TDNFGetGPGCheck(
PTDNF pTdnf,
const char* pszRepo,
int* pnGPGCheck,
char** ppszUrlGPGKey
)
{
uint32_t dwError = 0;
PTDNF_REPO_DATA pRepo = NULL;
int nGPGCheck = 0;
char* pszUrlGPGKey = NULL;
if(!pTdnf || !ppszUrlGPGKey || IsNullOrEmptyString(pszRepo))
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
if(!pTdnf->pArgs->nNoGPGCheck)
{
dwError = TDNFGetRepoById(pTdnf, pszRepo, &pRepo);
if(dwError == ERROR_TDNF_NO_DATA)
{
dwError = 0;
}
BAIL_ON_TDNF_ERROR(dwError);
if(pRepo)
{
nGPGCheck = pRepo->nGPGCheck;
if(nGPGCheck)
{
dwError = TDNFAllocateString(
pRepo->pszUrlGPGKey,
&pszUrlGPGKey);
BAIL_ON_TDNF_ERROR(dwError);
}
}
}
*pnGPGCheck = nGPGCheck;
*ppszUrlGPGKey = pszUrlGPGKey;
cleanup:
return dwError;
error:
if(ppszUrlGPGKey)
{
*ppszUrlGPGKey = NULL;
}
TDNF_SAFE_FREE_MEMORY(pszUrlGPGKey);
goto cleanup;
}
uint32_t
TDNFCliParsePackageArgs(
PTDNF_CMD_ARGS pCmdArgs,
char*** pppszPackageArgs,
int* pnPackageCount
)
{
uint32_t dwError = 0;
char** ppszPackageArgs = NULL;
int nPackageCount = 0;
int nIndex = 0;
if(!pCmdArgs || !pppszPackageArgs || !pnPackageCount)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_CLI_ERROR(dwError);
}
nPackageCount = pCmdArgs->nCmdCount - 1;
if(nPackageCount < 0)
{
dwError = ERROR_TDNF_CLI_NOT_ENOUGH_ARGS;
BAIL_ON_CLI_ERROR(dwError);
}
dwError = TDNFAllocateMemory(
nPackageCount + 1,
sizeof(char*),
(void**)&ppszPackageArgs);
BAIL_ON_CLI_ERROR(dwError);
for(nIndex = 0; nIndex < nPackageCount; ++nIndex)
{
dwError = TDNFAllocateString(
pCmdArgs->ppszCmds[nIndex+1],
&ppszPackageArgs[nIndex]);
BAIL_ON_CLI_ERROR(dwError);
}
*pppszPackageArgs = ppszPackageArgs;
cleanup:
return dwError;
error:
if(pppszPackageArgs)
{
*pppszPackageArgs = NULL;
}
TDNF_CLI_SAFE_FREE_STRINGARRAY(ppszPackageArgs);
goto cleanup;
}
uint32_t
AddSetOpt(
PTDNF_CMD_ARGS pCmdArgs,
const char* pszOptArg
)
{
uint32_t dwError = 0;
PTDNF_CMD_OPT pCmdOpt = NULL;
if(!pCmdArgs || IsNullOrEmptyString(pszOptArg))
{
dwError = ERROR_TDNF_CLI_INVALID_ARGUMENT;
BAIL_ON_CLI_ERROR(dwError);
}
dwError = GetOptionAndValue(pszOptArg, &pCmdOpt);
BAIL_ON_CLI_ERROR(dwError);
if(!strcmp(pCmdOpt->pszOptName, "tdnf.conf"))
{
TDNF_CLI_SAFE_FREE_MEMORY(pCmdArgs->pszConfFile);
dwError = TDNFAllocateString(
pCmdOpt->pszOptValue,
&pCmdArgs->pszConfFile);
BAIL_ON_CLI_ERROR(dwError);
}
cleanup:
if(pCmdOpt)
{
TDNFFreeCmdOpt(pCmdOpt);
}
return dwError;
error:
TDNF_CLI_SAFE_FREE_MEMORY(pCmdArgs->pszConfFile);
goto cleanup;
}
uint32_t
TDNFCliParseArgs(
int argc,
char* const* argv,
PTDNF_CMD_ARGS* ppCmdArgs
)
{
uint32_t dwError = 0;
PTDNF_CMD_ARGS pCmdArgs = NULL;
int nOptionIndex = 0;
int nOption = 0;
int nIndex = 0;
char* pszDefaultInstallRoot = "/";
if(!ppCmdArgs)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_CLI_ERROR(dwError);
}
dwError = TDNFAllocateMemory(
1,
sizeof(TDNF_CMD_ARGS),
(void**)&pCmdArgs);
BAIL_ON_CLI_ERROR(dwError);
opterr = 0;//tell getopt to not print errors
while (1)
{
nOption = getopt_long (
argc,
argv,
"46bCc:d:e:hiqvxy",
pstOptions,
&nOptionIndex);
if (nOption == -1)
break;
switch (nOption)
{
case 0:
dwError = ParseOption(
pstOptions[nOptionIndex].name,
optarg,
pCmdArgs);
BAIL_ON_CLI_ERROR(dwError);
break;
case 'b':
_opt.nBest = 1;
break;
case 'e':
break;
case 'C':
_opt.nCacheOnly = 1;
break;
case 'h':
_opt.nShowHelp = 1;
break;
case 'i':
dwError = TDNFAllocateString(
optarg,
&pCmdArgs->pszInstallRoot);
BAIL_ON_CLI_ERROR(dwError);
break;
case 'r':
break;
case 'y':
_opt.nAssumeYes = 1;
break;
case '4':
_opt.nIPv4 = 1;
break;
case '6':
_opt.nIPv6 = 1;
break;
case 'v':
_opt.nVerbose = 1;
break;
case '?':
dwError = HandleOptionsError(argv[optind-1], optarg, pstOptions);
BAIL_ON_CLI_ERROR(dwError);
//TODO: Handle unknown option, incomplete options
break;
}
}
if(pCmdArgs->pszInstallRoot == NULL)
{
dwError = TDNFAllocateString(
pszDefaultInstallRoot,
&pCmdArgs->pszInstallRoot);
BAIL_ON_CLI_ERROR(dwError);
}
dwError = TDNFCopyOptions(&_opt, pCmdArgs);
BAIL_ON_CLI_ERROR(dwError);
//Collect extra args
if (optind < argc)
{
pCmdArgs->nCmdCount = argc-optind;
dwError = TDNFAllocateMemory(
pCmdArgs->nCmdCount,
sizeof(char*),
(void**)&pCmdArgs->ppszCmds);
BAIL_ON_CLI_ERROR(dwError);
while (optind < argc)
{
dwError = TDNFAllocateString(
argv[optind++],
&pCmdArgs->ppszCmds[nIndex++]);
BAIL_ON_CLI_ERROR(dwError);
}
}
*ppCmdArgs = pCmdArgs;
cleanup:
return dwError;
error:
if(ppCmdArgs)
{
*ppCmdArgs = NULL;
}
if(pCmdArgs)
{
TDNFFreeCmdArgs(pCmdArgs);
}
goto cleanup;
}
