/*
* Prepare a SUP message for network sending.
*/
int sup_msg_set(sup_message_t * const msg, unsigned int msgtype,
uint32 sec_delta, uint32 nsec_delta, unsigned int flags,
char * const mscbuf, size_t msclen)
{
char * msccmd = "";
if (!msg) {
return ERR_SUP_HDR;
}
msg->sup_magic = htonl(SUP_MSG_MAGIC);
msg->process_id = htonq(proc_id);
msg->msg_type = htons((uint16)msgtype);
msg->sec_tdelta = htonl(sec_delta);
msg->nsec_tdelta = htonl(nsec_delta);
msg->flags = htonl((uint16)flags);
if (msgtype == DME_EV_ENTERED_CRITICAL_REG) {
msccmd = "activate_src";
} else if (msgtype == DME_EV_EXITED_CRITICAL_REG) {
msccmd = "deactivate_src";
}
snprintf(mscbuf, msclen, "%s(%u.%09u) %c%s",
evtostr(msgtype), sec_delta, nsec_delta,
MSC_SEP, msccmd);
return 0;
}
sha1oracle::sha1oracle (size_t nbytes, u_int64_t idx, size_t used)
: hashused (used), nctx ((nbytes + hashused - 1) / hashused),
state (New u_int32_t[nctx][hashwords]),
idx (htonq (idx)), resultsize (nbytes)
{
reset ();
}
/*! \brief Packs a 64 bit int into the buffer.
\param val The value to be packed.
*/
void Buffer::packInt64(uint64_t val){
uint64_t netval = htonq(val);
char *temp = (char *) realloc(data, datalen + 8);
data = temp;
temp += datalen;
memcpy(temp, &netval, 8);
datalen += 8;
}
/*
* Prepare a DME message header for network sending.
*/
int dme_header_set(dme_message_hdr_t * const hdr, unsigned int msgtype,
unsigned int msglen, unsigned int flags)
{
if (!hdr) {
return ERR_DME_HDR;
}
hdr->dme_magic = htonl(DME_MSG_MAGIC);
hdr->process_id = htonq(proc_id);
hdr->msg_type = htons((uint16)msgtype);
hdr->length = htons((uint16)msglen);
hdr->flags = htons((uint16)flags);;
return 0;
}
void
sha1oracle::consume (const u_char *p)
{
if (!firstblock) {
for (size_t i = 0; i < nctx; i++)
transform (state[i], p);
return;
}
firstblock = false;
assert (p == buffer);
for (size_t i = 0; i < nctx; i++) {
*reinterpret_cast<u_int64_t *> (buffer) = htonq (i);
transform (state[i], p);
}
}
/*!
* @brief Add a quad-work value TLV to a packet.
* @param packet Pointer to the packet to add the value to.
* @param type TLV type for the value.
* @param val The value to add to the packet.
* @return Indication of success or failure.
* @retval ERROR_SUCCESS The operation completed successfully.
* @retval ERROR_NOT_ENOUGH_MEMORY Insufficient memory available.
*/
DWORD packet_add_tlv_qword(Packet *packet, TlvType type, QWORD val)
{
val = htonq(val);
return packet_add_tlv_raw(packet, type, (PUCHAR)&val, sizeof(QWORD));
}
/*!
* @brief Handle the request to get the data from the clipboard.
* @details This function currently only supports the following clipboard data formats:
* - CF_TEXT - raw text data.
* - CF_DIB - bitmap/image information.
* - CF_HDROP - file selection.
*
* Over time more formats will be supported.
* @param remote Pointer to the remote endpoint.
* @param packet Pointer to the request packet.
* @return Indication of success or failure.
* @todo Add support for more data formats.
*/
DWORD request_clipboard_get_data(Remote *remote, Packet *packet)
{
#ifdef _WIN32
DWORD dwResult;
HMODULE hKernel32 = NULL;
HMODULE hUser32 = NULL;
HMODULE hShell32 = NULL;
PGLOBALLOCK pGlobalLock = NULL;
PGLOBALUNLOCK pGlobalUnlock = NULL;
POPENCLIPBOARD pOpenClipboard = NULL;
PCLOSECLIPBOARD pCloseClipboard = NULL;
PGETCLIPBOARDDATA pGetClipboardData = NULL;
PENUMCLIPBOARDFORMATS pEnumClipboardFormats = NULL;
PDRAGQUERYFILEA pDragQueryFileA = NULL;
PCREATEFILEA pCreateFileA = NULL;
PCLOSEHANDLE pCloseHandle = NULL;
PGETFILESIZEEX pGetFileSizeEx = NULL;
HANDLE hSourceFile = NULL;
PCHAR lpClipString = NULL;
HGLOBAL hClipboardData = NULL;
HDROP hFileDrop = NULL;
UINT uFormat = 0;
UINT uFileIndex = 0;
UINT uFileCount = 0;
CHAR lpFileName[MAX_PATH];
Tlv entries[2] = { 0 };
LARGE_INTEGER largeInt = { 0 };
LPBITMAPINFO lpBI = NULL;
PUCHAR lpDIB = NULL;
ConvertedImage image;
BOOL bImageDownload = FALSE;
DWORD dwWidth;
DWORD dwHeight;
Tlv imageTlv[3];
Packet *pResponse = packet_create_response(packet);
do
{
dprintf("[EXTAPI CLIPBOARD] Loading user32.dll");
if ((hUser32 = LoadLibraryA("user32.dll")) == NULL)
BREAK_ON_ERROR("[EXTAPI CLIPBOARD] Unable to load user32.dll");
dprintf("[EXTAPI CLIPBOARD] Loading kernel32.dll");
if ((hKernel32 = LoadLibraryA("kernel32.dll")) == NULL)
BREAK_ON_ERROR("[EXTAPI CLIPBOARD] Unable to load kernel32.dll");
dprintf("[EXTAPI CLIPBOARD] Searching for GlobalLock");
if ((pGlobalLock = (PGLOBALLOCK)GetProcAddress(hKernel32, "GlobalLock")) == NULL)
BREAK_ON_ERROR("[EXTAPI CLIPBOARD] Unable to locate GlobalLock in kernel32.dll");
dprintf("[EXTAPI CLIPBOARD] Searching for GlobalUnlock");
if ((pGlobalUnlock = (PGLOBALUNLOCK)GetProcAddress(hKernel32, "GlobalUnlock")) == NULL)
BREAK_ON_ERROR("[EXTAPI CLIPBOARD] Unable to locate GlobalUnlock in kernel32.dll");
dprintf("[EXTAPI CLIPBOARD] Searching for OpenClipboard");
if ((pOpenClipboard = (POPENCLIPBOARD)GetProcAddress(hUser32, "OpenClipboard")) == NULL)
BREAK_ON_ERROR("[EXTAPI CLIPBOARD] Unable to locate OpenClipboard in user32.dll");
dprintf("[EXTAPI CLIPBOARD] Searching for CloseClipboard");
if ((pCloseClipboard = (PCLOSECLIPBOARD)GetProcAddress(hUser32, "CloseClipboard")) == NULL)
BREAK_ON_ERROR("[EXTAPI CLIPBOARD] Unable to locate CloseClipboard in user32.dll");
dprintf("[EXTAPI CLIPBOARD] Searching for GetClipboardData");
if ((pGetClipboardData = (PGETCLIPBOARDDATA)GetProcAddress(hUser32, "GetClipboardData")) == NULL)
BREAK_ON_ERROR("[EXTAPI CLIPBOARD] Unable to locate GetClipboardData in user32.dll");
dprintf("[EXTAPI CLIPBOARD] Searching for EnumClipboardFormats");
if ((pEnumClipboardFormats = (PENUMCLIPBOARDFORMATS)GetProcAddress(hUser32, "EnumClipboardFormats")) == NULL)
BREAK_ON_ERROR("[EXTAPI CLIPBOARD] Unable to locate EnumClipboardFormats in user32.dll");
// Try to get a lock on the clipboard
if (!pOpenClipboard(NULL)) {
dwResult = GetLastError();
BREAK_WITH_ERROR("[EXTAPI CLIPBOARD] Unable to open the clipboard", dwResult);
}
dprintf("[EXTAPI CLIPBOARD] Clipboard locked, attempting to get data...");
while (uFormat = pEnumClipboardFormats(uFormat))
{
if (uFormat == CF_TEXT) {
// there's raw text on the clipboard
if ((hClipboardData = pGetClipboardData(CF_TEXT)) != NULL
&& (lpClipString = (PCHAR)pGlobalLock(hClipboardData)) != NULL) {
dprintf("[EXTAPI CLIPBOARD] Clipboard text captured: %s", lpClipString);
packet_add_tlv_string(pResponse, TLV_TYPE_EXT_CLIPBOARD_TYPE_TEXT, lpClipString);
pGlobalUnlock(hClipboardData);
}
}
else if (uFormat == CF_DIB) {
dprintf("[EXTAPI CLIPBOARD] Grabbing the clipboard bitmap data");
// an image of some kind is on the clipboard
if ((hClipboardData = pGetClipboardData(CF_DIB)) != NULL
&& (lpBI = (LPBITMAPINFO)pGlobalLock(hClipboardData)) != NULL) {
dprintf("[EXTAPI CLIPBOARD] CF_DIB grabbed, extracting dimensions.");
// grab the bitmap image size
dwWidth = htonl(lpBI->bmiHeader.biWidth);
dwHeight = htonl(lpBI->bmiHeader.biHeight);
imageTlv[0].header.type = TLV_TYPE_EXT_CLIPBOARD_TYPE_IMAGE_JPG_DIMX;
imageTlv[0].header.length = sizeof(UINT);
imageTlv[0].buffer = (PUCHAR)&dwWidth;
imageTlv[1].header.type = TLV_TYPE_EXT_CLIPBOARD_TYPE_IMAGE_JPG_DIMY;
imageTlv[1].header.length = sizeof(UINT);
imageTlv[1].buffer = (PUCHAR)&dwHeight;
// only download the image if they want it
bImageDownload = packet_get_tlv_value_bool(packet, TLV_TYPE_EXT_CLIPBOARD_DOWNLOAD);
dprintf("[EXTAPI CLIPBOARD] Image is %dx%d and %s be downloaded", lpBI->bmiHeader.biWidth, lpBI->bmiHeader.biHeight,
bImageDownload ? "WILL" : "will NOT");
if (!bImageDownload) {
packet_add_tlv_group(pResponse, TLV_TYPE_EXT_CLIPBOARD_TYPE_IMAGE_JPG, imageTlv, 2);
}
else {
lpDIB = ((PUCHAR)lpBI) + get_bitmapinfo_size(lpBI, TRUE);
// TODO: add the ability to encode with multiple encoders and return the smallest image.
if (convert_to_jpg(lpBI, lpDIB, 75, &image) == ERROR_SUCCESS) {
dprintf("[EXTAPI CLIPBOARD] Clipboard bitmap captured to image: %p, Size: %u bytes", image.pImageBuffer, image.dwImageBufferSize);
imageTlv[2].header.type = TLV_TYPE_EXT_CLIPBOARD_TYPE_IMAGE_JPG_DATA;
imageTlv[2].header.length = image.dwImageBufferSize;
imageTlv[2].buffer = (PUCHAR)image.pImageBuffer;
packet_add_tlv_group(pResponse, TLV_TYPE_EXT_CLIPBOARD_TYPE_IMAGE_JPG, imageTlv, 3);
// Just leaving this in for debugging purposes later on
//hSourceFile = CreateFileA("C:\\temp\\foo.jpg", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
//WriteFile(hSourceFile, image.pImageBuffer, image.dwImageBufferSize, &largeInt.LowPart, NULL);
//CloseHandle(hSourceFile);
free(image.pImageBuffer);
}
else {
dwResult = GetLastError();
dprintf("[EXTAPI CLIPBOARD] Failed to convert clipboard image to JPG");
}
}
pGlobalUnlock(hClipboardData);
}
else {
dwResult = GetLastError();
dprintf("[EXTAPI CLIPBOARD] Failed to get access to the CF_DIB information");
}
}
else if (uFormat == CF_HDROP) {
// there's one or more files on the clipboard
dprintf("[EXTAPI CLIPBOARD] Files have been located on the clipboard");
do
{
dprintf("[EXTAPI CLIPBOARD] Loading shell32.dll");
if ((hShell32 = LoadLibraryA("shell32.dll")) == NULL)
BREAK_ON_ERROR("[EXTAPI CLIPBOARD] Unable to load shell32.dll");
dprintf("[EXTAPI CLIPBOARD] Searching for CreateFileA");
if ((pCreateFileA = (PCREATEFILEA)GetProcAddress(hKernel32, "CreateFileA")) == NULL)
BREAK_ON_ERROR("[EXTAPI CLIPBOARD] Unable to locate CreateFileA in kernel32.dll");
dprintf("[EXTAPI CLIPBOARD] Searching for CloseHandle");
if ((pCloseHandle = (PCLOSEHANDLE)GetProcAddress(hKernel32, "CloseHandle")) == NULL)
BREAK_ON_ERROR("[EXTAPI CLIPBOARD] Unable to locate CloseHandle in kernel32.dll");
dprintf("[EXTAPI CLIPBOARD] Searching for GetFileSizeEx");
if ((pGetFileSizeEx = (PGETFILESIZEEX)GetProcAddress(hKernel32, "GetFileSizeEx")) == NULL)
BREAK_ON_ERROR("[EXTAPI CLIPBOARD] Unable to locate GetFileSizeEx in kernel32.dll");
dprintf("[EXTAPI CLIPBOARD] Searching for DragQueryFileA");
if ((pDragQueryFileA = (PDRAGQUERYFILEA)GetProcAddress(hShell32, "DragQueryFileA")) == NULL)
BREAK_ON_ERROR("[EXTAPI CLIPBOARD] Unable to locate CloseClipboard in shell32.dll");
dprintf("[EXTAPI CLIPBOARD] Grabbing the clipboard file drop data");
if ((hClipboardData = pGetClipboardData(CF_HDROP)) != NULL
&& (hFileDrop = (HDROP)pGlobalLock(hClipboardData)) != NULL) {
uFileCount = pDragQueryFileA(hFileDrop, (UINT)-1, NULL, 0);
dprintf("[EXTAPI CLIPBOARD] Parsing %u file(s) on the clipboard.", uFileCount);
for (uFileIndex = 0; uFileIndex < uFileCount; ++uFileIndex) {
if (pDragQueryFileA(hFileDrop, uFileIndex, lpFileName, sizeof(lpFileName))) {
dprintf("[EXTAPI CLIPBOARD] Clipboard file entry: %s", lpFileName);
memset(&entries, 0, sizeof(entries));
memset(&largeInt, 0, sizeof(largeInt));
entries[0].header.type = TLV_TYPE_EXT_CLIPBOARD_TYPE_FILE_NAME;
entries[0].header.length = (DWORD)strlen(lpFileName) + 1;
entries[0].buffer = (PUCHAR)lpFileName;
entries[1].header.type = TLV_TYPE_EXT_CLIPBOARD_TYPE_FILE_SIZE;
entries[1].header.length = sizeof(QWORD);
entries[1].buffer = (PUCHAR)&largeInt.QuadPart;
if ((hSourceFile = pCreateFileA(lpFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) != NULL) {
if (pGetFileSizeEx(hSourceFile, &largeInt)) {
largeInt.QuadPart = htonq(largeInt.QuadPart);
}
pCloseHandle(hSourceFile);
}
packet_add_tlv_group(pResponse, TLV_TYPE_EXT_CLIPBOARD_TYPE_FILE, entries, 2);
}
}
pGlobalUnlock(hClipboardData);
}
} while (0);
}
}
dwResult = GetLastError();
pCloseClipboard();
} while (0);
if (hShell32)
FreeLibrary(hShell32);
if (hKernel32)
FreeLibrary(hKernel32);
if (hUser32)
FreeLibrary(hUser32);
if (pResponse)
packet_transmit_response(dwResult, remote, pResponse);
return dwResult;
#else
return ERROR_NOT_SUPPORTED;
#endif
}
STATIC void
mod_pdu(pdu_t *pdu, iscsi_pdu_mod_t *mp)
{
int add = mp->flags & ISCSITEST_MOD_FLAG_ADD_VAL;
int64_t val = *((int64_t *) mp->value);
uint8_t *ptr;
int len;
switch (mp->offset) {
case ISCSITEST_OFFSET_DATADIGEST:
ptr = (uint8_t *) &pdu->data_digest;
len = sizeof(pdu->data_digest);
break;
case ISCSITEST_OFFSET_HEADERDIGEST:
ptr = (uint8_t *) &pdu->pdu.HeaderDigest;
len = sizeof(pdu->pdu.HeaderDigest);
break;
case ISCSITEST_OFFSET_DATA:
if ((len = pdu->io_vec[1].iov_len) == 0)
return;
ptr = pdu->io_vec[1].iov_base;
break;
case ISCSITEST_OFFSET_DRV_CMDSN:
ptr = (uint8_t *) &pdu->connection->session->CmdSN;
len = sizeof(pdu->connection->session->CmdSN);
break;
default:
if (find_pdu_offset(pdu, mp->offset, &ptr, &len))
return;
break;
}
len = min(len, mp->size);
DEB(1, ("mod_pdu: mpoff=%d, size=%d, len=%d, val=%qx, *ptr=%qx\n",
mp->offset, mp->size, len, val, *((uint64_t *) ptr)));
if (!add) {
if (mp->flags & ISCSITEST_MOD_FLAG_REORDER)
val = htonq(val);
memcpy(ptr, &val, len);
} else if (len == mp->size) {
switch (len) {
case 1:
*ptr += *mp->value;
break;
case 2:
val += (int64_t) (ntohs(*((uint16_t *) ptr)));
*((uint16_t *) ptr) = htons((uint16_t) val);
break;
case 3:
val += (int64_t) (ntoh3(ptr));
hton3((uint32_t) val, ptr);
break;
case 4:
val += (int64_t) (ntohl(*((uint32_t *) ptr)));
*((uint32_t *) ptr) = htonl((uint32_t) val);
break;
case 8:
val += ntohq(*((uint64_t *) ptr));
*((uint64_t *) ptr) = htonq(val);
break;
default:
break;
}
}
DEB(1, ("mod_pdu: *ptr=%qx\n", *((uint64_t *) ptr)));
}
