CDB_SendDataCmd* CDB_CursorCmd::SendDataCmd(unsigned int item_num,
size_t size,
bool log_it,
bool dump_results)
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->SendDataCmd(item_num, size, log_it, dump_results);
}
bool CDB_RPCCmd::Send()
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->Send();
}
int asm_cmd_convert(const char* word, int* c)
{
*c = CHECK_COMMAND(word, PUSH)
CHECK_COMMAND(word, POP)
CHECK_COMMAND(word, ADD)
CHECK_COMMAND(word, SUB)
CHECK_COMMAND(word, MUL)
CHECK_COMMAND(word, DIV)
CHECK_COMMAND(word, SIN)
CHECK_COMMAND(word, COS)
CHECK_COMMAND(word, TAN)
CHECK_COMMAND(word, SQRT)
CHECK_COMMAND(word, POW)
CHECK_COMMAND(word, END)
CHECK_COMMAND(word, DUMP)
CHECK_COMMAND(word, ENTER)
CHECK_COMMAND(word, TAB)
CHECK_COMMAND(word, SPACE)
CHECK_COMMAND(word, OUT)
CHECK_COMMAND(word, MOV)
CHECK_COMMAND(word, SWAP)
CHECK_COMMAND(word, DUB)
CHECK_COMMAND(word, JMP)
CHECK_COMMAND(word, JBE)
CHECK_COMMAND(word, JB)
CHECK_COMMAND(word, JAE)
CHECK_COMMAND(word, JA)
CHECK_COMMAND(word, JE)
CHECK_COMMAND(word, JNE)
CHECK_COMMAND(word, FUNC)
CHECK_COMMAND(word, CALL)
CHECK_COMMAND(word, RET)
CHECK_COMMAND(word, IN)
CHECK_COMMAND(word, LN)
CHECK_COMMAND(word, ASIN)
CHECK_COMMAND(word, FAC)
CHECK_COMMAND(word, DEF)
CMD_NONE;
if (*c == CMD_NONE) return ASM_BAD_COMMAND_TOKEN;
return ASM_OK;
}
void CDB_SendDataCmd::DumpResults()
{
CHECK_COMMAND( m_CmdImpl );
m_CmdImpl->DumpResults();
}
CDB_Result* CDB_SendDataCmd::Result()
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->Result();
}
int CDB_CursorCmd::RowCount() const
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->RowCount();
}
bool CDB_CursorCmd::Update(const string& table_name, const string& upd_query)
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->Update(table_name, upd_query);
}
const string& CDB_RPCCmd::GetProcName(void) const
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->GetQuery();
}
void CDB_BCPInCmd::SetHints(CTempString hints)
{
CHECK_COMMAND( m_CmdImpl );
m_CmdImpl->SetHints(hints);
}
void CDB_RPCCmd::DumpResults()
{
CHECK_COMMAND( m_CmdImpl );
m_CmdImpl->DumpResults();
}
void CDB_RPCCmd::SetRecompile(bool recompile)
{
CHECK_COMMAND( m_CmdImpl );
m_CmdImpl->SetRecompile(recompile);
}
bool CDB_RPCCmd::HasFailed() const
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->HasFailed();
}
bool CDB_RPCCmd::WasCanceled() const
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->WasCanceled();
}
bool CDB_RPCCmd::WasSent() const
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->WasSent();
}
CDBParams& CDB_CursorCmd::GetDefineParams(void)
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->GetDefineParams();
}
void CDB_BCPInCmd::AddHint(EBCP_Hints hint, unsigned int value /* = 0 */)
{
CHECK_COMMAND( m_CmdImpl );
m_CmdImpl->AddHint(hint, value);
}
CDB_Result* CDB_CursorCmd::Open()
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->OpenCursor();
}
void CDB_BCPInCmd::AddOrderHint(CTempString columns)
{
CHECK_COMMAND( m_CmdImpl );
m_CmdImpl->AddOrderHint(columns);
}
bool CDB_CursorCmd::UpdateTextImage(unsigned int item_num, CDB_Stream& data, bool log_it)
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->UpdateTextImage(item_num, data, log_it);
}
CDBParams& CDB_BCPInCmd::GetBindParams(void)
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->GetBindParams();
}
bool CDB_CursorCmd::Delete(const string& table_name)
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->Delete(table_name);
}
bool CDB_BCPInCmd::SendRow()
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->Send();
}
bool CDB_CursorCmd::Close()
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->CloseCursor();
}
bool CDB_BCPInCmd::Cancel()
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->Cancel();
}
bool CDB_SendDataCmd::HasMoreResults() const
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->HasMoreResults();
}
bool CDB_BCPInCmd::CompleteBatch()
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->CommitBCPTrans();
}
int
auth_dovecot_server(auth_instance * ablock, uschar * data)
{
auth_dovecot_options_block *ob =
(auth_dovecot_options_block *) ablock->options_block;
struct sockaddr_un sa;
uschar buffer[DOVECOT_AUTH_MAXLINELEN];
uschar *args[DOVECOT_AUTH_MAXFIELDCOUNT];
uschar *auth_command;
uschar *auth_extra_data = US"";
uschar *p;
int nargs, tmp;
int crequid = 1, cont = 1, fd = -1, ret = DEFER;
BOOL found = FALSE, have_mech_line = FALSE;
HDEBUG(D_auth) debug_printf("dovecot authentication\n");
if (!data)
{
ret = FAIL;
goto out;
}
memset(&sa, 0, sizeof(sa));
sa.sun_family = AF_UNIX;
/* This was the original code here: it is nonsense because strncpy()
does not return an integer. I have converted this to use the function
that formats and checks length. PH */
/*
if (strncpy(sa.sun_path, ob->server_socket, sizeof(sa.sun_path)) < 0) {
}
*/
if (!string_format(US sa.sun_path, sizeof(sa.sun_path), "%s",
ob->server_socket))
{
auth_defer_msg = US"authentication socket path too long";
return DEFER;
}
auth_defer_msg = US"authentication socket connection error";
if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
return DEFER;
if (connect(fd, (struct sockaddr *) &sa, sizeof(sa)) < 0)
goto out;
auth_defer_msg = US"authentication socket protocol error";
socket_buffer_left = 0; /* Global, used to read more than a line but return by line */
while (cont)
{
if (dc_gets(buffer, sizeof(buffer), fd) == NULL)
OUT("authentication socket read error or premature eof");
p = buffer + Ustrlen(buffer) - 1;
if (*p != '\n')
OUT("authentication socket protocol line too long");
*p = '\0';
HDEBUG(D_auth) debug_printf("received: %s\n", buffer);
nargs = strcut(buffer, args, sizeof(args) / sizeof(args[0]));
/* HDEBUG(D_auth) debug_strcut(args, nargs, sizeof(args) / sizeof(args[0])); */
/* Code below rewritten by Kirill Miazine ([email protected]). Only check commands that
Exim will need. Original code also failed if Dovecot server sent unknown
command. E.g. COOKIE in version 1.1 of the protocol would cause troubles. */
/* pdp: note that CUID is a per-connection identifier sent by the server,
which increments at server discretion.
By contrast, the "id" field of the protocol is a connection-specific request
identifier, which needs to be unique per request from the client and is not
connected to the CUID value, so we ignore CUID from server. It's purely for
diagnostics. */
if (Ustrcmp(args[0], US"VERSION") == 0)
{
CHECK_COMMAND("VERSION", 2, 2);
if (Uatoi(args[1]) != VERSION_MAJOR)
OUT("authentication socket protocol version mismatch");
}
else if (Ustrcmp(args[0], US"MECH") == 0)
{
CHECK_COMMAND("MECH", 1, INT_MAX);
have_mech_line = TRUE;
if (strcmpic(US args[1], ablock->public_name) == 0)
found = TRUE;
}
else if (Ustrcmp(args[0], US"SPID") == 0)
{
/* Unfortunately the auth protocol handshake wasn't designed well
to differentiate between auth-client/userdb/master. auth-userdb
and auth-master send VERSION + SPID lines only and nothing
afterwards, while auth-client sends VERSION + MECH + SPID +
CUID + more. The simplest way that we can determine if we've
connected to the correct socket is to see if MECH line exists or
not (alternatively we'd have to have a small timeout after SPID
to see if CUID is sent or not). */
if (!have_mech_line)
OUT("authentication socket type mismatch"
" (connected to auth-master instead of auth-client)");
}
else if (Ustrcmp(args[0], US"DONE") == 0)
{
CHECK_COMMAND("DONE", 0, 0);
cont = 0;
}
}
if (!found)
{
auth_defer_msg = string_sprintf(
"Dovecot did not advertise mechanism \"%s\" to us", ablock->public_name);
goto out;
}
/* Added by PH: data must not contain tab (as it is
b64 it shouldn't, but check for safety). */
if (Ustrchr(data, '\t') != NULL)
{
ret = FAIL;
goto out;
}
/* Added by PH: extra fields when TLS is in use or if the TCP/IP
connection is local. */
if (tls_in.cipher != NULL)
auth_extra_data = string_sprintf("secured\t%s%s",
tls_in.certificate_verified? "valid-client-cert" : "",
tls_in.certificate_verified? "\t" : "");
else if ( interface_address != NULL
&& Ustrcmp(sender_host_address, interface_address) == 0)
auth_extra_data = US"secured\t";
/****************************************************************************
The code below was the original code here. It didn't work. A reading of the
file auth-protocol.txt.gz that came with Dovecot 1.0_beta8 indicated that
this was not right. Maybe something changed. I changed it to move the
service indication into the AUTH command, and it seems to be better. PH
fprintf(f, "VERSION\t%d\t%d\r\nSERVICE\tSMTP\r\nCPID\t%d\r\n"
"AUTH\t%d\t%s\trip=%s\tlip=%s\tresp=%s\r\n",
VERSION_MAJOR, VERSION_MINOR, getpid(), cuid,
ablock->public_name, sender_host_address, interface_address,
data ? CS data : "");
Subsequently, the command was modified to add "secured" and "valid-client-
cert" when relevant.
****************************************************************************/
auth_command = string_sprintf("VERSION\t%d\t%d\nCPID\t%d\n"
"AUTH\t%d\t%s\tservice=smtp\t%srip=%s\tlip=%s\tnologin\tresp=%s\n",
VERSION_MAJOR, VERSION_MINOR, getpid(), crequid,
ablock->public_name, auth_extra_data, sender_host_address,
interface_address, data);
if (write(fd, auth_command, Ustrlen(auth_command)) < 0)
HDEBUG(D_auth) debug_printf("error sending auth_command: %s\n",
strerror(errno));
HDEBUG(D_auth) debug_printf("sent: %s", auth_command);
while (1)
{
uschar *temp;
uschar *auth_id_pre = NULL;
int i;
if (dc_gets(buffer, sizeof(buffer), fd) == NULL)
{
auth_defer_msg = US"authentication socket read error or premature eof";
goto out;
}
buffer[Ustrlen(buffer) - 1] = 0;
HDEBUG(D_auth) debug_printf("received: %s\n", buffer);
nargs = strcut(buffer, args, sizeof(args) / sizeof(args[0]));
if (Uatoi(args[1]) != crequid)
OUT("authentication socket connection id mismatch");
switch (toupper(*args[0]))
{
case 'C':
CHECK_COMMAND("CONT", 1, 2);
if ((tmp = auth_get_no64_data(&data, US args[2])) != OK)
{
ret = tmp;
goto out;
}
/* Added by PH: data must not contain tab (as it is
b64 it shouldn't, but check for safety). */
if (Ustrchr(data, '\t') != NULL)
{
ret = FAIL;
goto out;
}
temp = string_sprintf("CONT\t%d\t%s\n", crequid, data);
if (write(fd, temp, Ustrlen(temp)) < 0)
OUT("authentication socket write error");
break;
case 'F':
CHECK_COMMAND("FAIL", 1, -1);
for (i=2; (i<nargs) && (auth_id_pre == NULL); i++)
{
if ( Ustrncmp(args[i], US"user="******"OK", 2, -1);
/* Search for the "user=$USER" string in the args array
and return the proper value. */
for (i=2; (i<nargs) && (auth_id_pre == NULL); i++)
{
if ( Ustrncmp(args[i], US"user="******"authentication socket protocol error, username missing");
ret = OK;
/* fallthrough */
default:
goto out;
}
}
out:
/* close the socket used by dovecot */
if (fd >= 0)
close(fd);
/* Expand server_condition as an authorization check */
return ret == OK ? auth_check_serv_cond(ablock) : ret;
}
bool CDB_BCPInCmd::CompleteBCP()
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->EndBCP();
}
static IMG_VOID _RGXClientCCBDumpCommands(RGX_CLIENT_CCB *psClientCCB,
IMG_UINT32 ui32Offset,
IMG_UINT32 ui32ByteCount)
{
#if defined(SUPPORT_DUMP_CLIENT_CCB_COMMANDS)
IMG_UINT8 *pui8Ptr = psClientCCB->pui8ClientCCB + ui32Offset;
IMG_UINT32 ui32ConsumeSize = ui32ByteCount;
while (ui32ConsumeSize)
{
RGXFWIF_CCB_CMD_HEADER *psHeader = (RGXFWIF_CCB_CMD_HEADER *) pui8Ptr;
IMG_BOOL bFenceUpdate = IMG_FALSE;
PVR_DPF((SUPPORT_DUMP_CLIENT_CCB_COMMANDS_DBG_LEVEL, "@offset 0x%08x", pui8Ptr - psClientCCB->pui8ClientCCB));
switch(psHeader->eCmdType)
{
CHECK_COMMAND(TA, IMG_FALSE);
CHECK_COMMAND(3D, IMG_FALSE);
CHECK_COMMAND(CDM, IMG_FALSE);
CHECK_COMMAND(TQ_3D, IMG_FALSE);
CHECK_COMMAND(TQ_2D, IMG_FALSE);
CHECK_COMMAND(3D_PR, IMG_FALSE);
CHECK_COMMAND(NULL, IMG_FALSE);
CHECK_COMMAND(SHG, IMG_FALSE);
CHECK_COMMAND(RTU, IMG_FALSE);
CHECK_COMMAND(RTU_FC, IMG_FALSE);
CHECK_COMMAND(PRE_TIMESTAMP, IMG_FALSE);
CHECK_COMMAND(POST_TIMESTAMP, IMG_FALSE);
CHECK_COMMAND(FENCE, IMG_TRUE);
CHECK_COMMAND(UPDATE, IMG_TRUE);
CHECK_COMMAND(RMW_UPDATE, IMG_TRUE);
CHECK_COMMAND(FENCE_PR, IMG_TRUE);
CHECK_COMMAND(PADDING, IMG_FALSE);
default:
PVR_DPF((SUPPORT_DUMP_CLIENT_CCB_COMMANDS_DBG_LEVEL, "Unknown command!"));
break;
}
pui8Ptr += sizeof(*psHeader);
if (bFenceUpdate)
{
IMG_UINT32 j;
RGXFWIF_UFO *psUFOPtr = (RGXFWIF_UFO *) pui8Ptr;
for (j=0;j<psHeader->ui32CmdSize/sizeof(RGXFWIF_UFO);j++)
{
PVR_DPF((SUPPORT_DUMP_CLIENT_CCB_COMMANDS_DBG_LEVEL, "Addr = 0x%08x, value = 0x%08x",
psUFOPtr[j].puiAddrUFO.ui32Addr, psUFOPtr[j].ui32Value));
}
}
else
{
IMG_UINT32 *pui32Ptr = (IMG_UINT32 *) pui8Ptr;
IMG_UINT32 ui32Remain = psHeader->ui32CmdSize/sizeof(IMG_UINT32);
while(ui32Remain)
{
if (ui32Remain >= 4)
{
PVR_DPF((SUPPORT_DUMP_CLIENT_CCB_COMMANDS_DBG_LEVEL, "0x%08x 0x%08x 0x%08x 0x%08x",
pui32Ptr[0], pui32Ptr[1], pui32Ptr[2], pui32Ptr[3]));
pui32Ptr += 4;
ui32Remain -= 4;
}
if (ui32Remain == 3)
{
PVR_DPF((SUPPORT_DUMP_CLIENT_CCB_COMMANDS_DBG_LEVEL, "0x%08x 0x%08x 0x%08x",
pui32Ptr[0], pui32Ptr[1], pui32Ptr[2]));
pui32Ptr += 3;
ui32Remain -= 3;
}
if (ui32Remain == 2)
{
PVR_DPF((SUPPORT_DUMP_CLIENT_CCB_COMMANDS_DBG_LEVEL, "0x%08x 0x%08x",
pui32Ptr[0], pui32Ptr[1]));
pui32Ptr += 2;
ui32Remain -= 2;
}
if (ui32Remain == 1)
{
PVR_DPF((SUPPORT_DUMP_CLIENT_CCB_COMMANDS_DBG_LEVEL, "0x%08x",
pui32Ptr[0]));
pui32Ptr += 1;
ui32Remain -= 1;
}
}
}
pui8Ptr += psHeader->ui32CmdSize;
ui32ConsumeSize -= sizeof(*psHeader) + psHeader->ui32CmdSize;
}
#else
PVR_UNREFERENCED_PARAMETER(psClientCCB);
PVR_UNREFERENCED_PARAMETER(ui32Offset);
PVR_UNREFERENCED_PARAMETER(ui32ByteCount);
#endif
}
CDB_Result* CDB_LangCmd::Result()
{
CHECK_COMMAND( m_CmdImpl );
return m_CmdImpl->Result();
}