uint64_t tobe64(uint64_t x) { return htobe64(x); }
uint64_t socketHost2Netwok64(uint64_t host64)
{
return htobe64(host64);
}
string uint64_to_big_endian_text(uint64_t value) {
uint64_t big_value = htobe64(value);
return string(static_cast<char*>(static_cast<void*>(&big_value)),
sizeof(big_value));
}
int build_phys_page_list(struct ib_phys_buf *buffer_list,
int num_phys_buf,
u64 *iova_start,
u64 *total_size,
int *npages,
int *shift,
__be64 **page_list)
{
u64 mask;
int i, j, n;
mask = 0;
*total_size = 0;
for (i = 0; i < num_phys_buf; ++i) {
if (i != 0 && buffer_list[i].addr & ~PAGE_MASK)
return (-EINVAL);
if (i != 0 && i != num_phys_buf - 1 &&
(buffer_list[i].size & ~PAGE_MASK))
return (-EINVAL);
*total_size += buffer_list[i].size;
if (i > 0)
mask |= buffer_list[i].addr;
else
mask |= buffer_list[i].addr & PAGE_MASK;
if (i != num_phys_buf - 1)
mask |= buffer_list[i].addr + buffer_list[i].size;
else
mask |= (buffer_list[i].addr + buffer_list[i].size +
PAGE_SIZE - 1) & PAGE_MASK;
}
if (*total_size > 0xFFFFFFFFULL)
return (-ENOMEM);
/* Find largest page shift we can use to cover buffers */
for (*shift = PAGE_SHIFT; *shift < 27; ++(*shift))
if ((1ULL << *shift) & mask)
break;
buffer_list[0].size += buffer_list[0].addr & ((1ULL << *shift) - 1);
buffer_list[0].addr &= ~0ull << *shift;
*npages = 0;
for (i = 0; i < num_phys_buf; ++i)
*npages += (buffer_list[i].size +
(1ULL << *shift) - 1) >> *shift;
if (!*npages)
return (-EINVAL);
*page_list = kmalloc(sizeof(u64) * *npages, M_NOWAIT);
if (!*page_list)
return (-ENOMEM);
n = 0;
for (i = 0; i < num_phys_buf; ++i)
for (j = 0;
j < (buffer_list[i].size + (1ULL << *shift) - 1) >> *shift;
++j)
(*page_list)[n++] = htobe64(buffer_list[i].addr +
((u64) j << *shift));
CTR6(KTR_IW_CXGB, "%s va 0x%llx mask 0x%llx shift %d len %lld pbl_size %d",
__FUNCTION__, (unsigned long long) *iova_start,
(unsigned long long) mask, *shift, (unsigned long long) *total_size,
*npages);
return 0;
}
void sendPosition() {
int64_t pos = htobe64(mpris_data->position);
transmitMsg(client_socket, (char*)&pos, sizeof(int64_t),
POSITION, POSITION_SZ);
}
static int
xlp_rsa_init(struct xlp_rsa_softc *sc, int node)
{
struct xlp_rsa_command *cmd = NULL;
uint32_t fbvc, dstvc, endsel, regval;
struct nlm_fmn_msg m;
int err, ret, i;
uint64_t base;
/* Register interrupt handler for the RSA/ECC CMS messages */
if (register_msgring_handler(sc->rsaecc_vc_start,
sc->rsaecc_vc_end, nlm_xlprsaecc_msgring_handler, sc) != 0) {
err = -1;
printf("Couldn't register rsa/ecc msgring handler\n");
goto errout;
}
fbvc = nlm_cpuid() * 4 + XLPGE_FB_VC;
/* Do the CMS credit initialization */
/* Currently it is configured by default to 50 when kernel comes up */
#if BYTE_ORDER == LITTLE_ENDIAN
for (i = 0; i < nitems(nlm_rsa_ucode_data); i++)
nlm_rsa_ucode_data[i] = htobe64(nlm_rsa_ucode_data[i]);
#endif
for (dstvc = sc->rsaecc_vc_start; dstvc <= sc->rsaecc_vc_end; dstvc++) {
cmd = malloc(sizeof(struct xlp_rsa_command), M_DEVBUF,
M_NOWAIT | M_ZERO);
KASSERT(cmd != NULL, ("%s:cmd is NULL\n", __func__));
cmd->rsasrc = contigmalloc(sizeof(nlm_rsa_ucode_data),
M_DEVBUF,
(M_WAITOK | M_ZERO),
0UL /* low address */, -1UL /* high address */,
XLP_L2L3_CACHELINE_SIZE /* alignment */,
0UL /* boundary */);
KASSERT(cmd->rsasrc != NULL,
("%s:cmd->rsasrc is NULL\n", __func__));
memcpy(cmd->rsasrc, nlm_rsa_ucode_data,
sizeof(nlm_rsa_ucode_data));
m.msg[0] = nlm_crypto_form_rsa_ecc_fmn_entry0(1, 0x70, 0,
vtophys(cmd->rsasrc));
m.msg[1] = nlm_crypto_form_rsa_ecc_fmn_entry1(0, 1, fbvc,
vtophys(cmd->rsasrc));
/* Software scratch pad */
m.msg[2] = (uintptr_t)cmd;
m.msg[3] = 0;
ret = nlm_fmn_msgsend(dstvc, 3, FMN_SWCODE_RSA, &m);
if (ret != 0) {
err = -1;
printf("%s: msgsnd failed (%x)\n", __func__, ret);
goto errout;
}
}
/* Configure so that all VCs send request to all RSA pipes */
base = nlm_get_rsa_regbase(node);
if (nlm_is_xlp3xx()) {
endsel = 1;
regval = 0xFFFF;
} else {
endsel = 3;
regval = 0x07FFFFFF;
}
for (i = 0; i < endsel; i++)
nlm_write_rsa_reg(base, RSA_ENG_SEL_0 + i, regval);
return (0);
errout:
xlp_free_cmd_params(cmd);
return (err);
}
static void
fmtLogMsg(StringInfo dst, ErrorData *edata)
{
{
char formattedLogTime[FORMATTED_TS_LEN];
/* timestamp with milliseconds */
formatNow(formattedLogTime, sizeof formattedLogTime);
/*
* Always present, non-nullable; don't need to write the N/P
* header.
*/
appendStringInfoString(dst, formattedLogTime);
appendStringInfoChar(dst, '\0');
}
/* username */
if (MyProcPort)
appendStringInfoPtr(dst, MyProcPort->user_name);
else
appendStringInfoPtr(dst, NULL);
/* database name */
if (MyProcPort)
appendStringInfoPtr(dst, MyProcPort->database_name);
else
appendStringInfoPtr(dst, NULL);
/* Process id */
{
uint32_t nPid = htobe32(savedPid);
appendBinaryStringInfo(dst, (void *) &nPid, sizeof nPid);
}
/* Remote host and port */
if (MyProcPort && MyProcPort->remote_host)
{
/* 'present' string header, since this string is nullable */
appendStringInfoChar(dst, 'P');
appendStringInfoString(dst, MyProcPort->remote_host);
if (MyProcPort->remote_port && MyProcPort->remote_port[0] != '\0')
{
appendStringInfoChar(dst, ':');
appendStringInfoString(dst, MyProcPort->remote_port);
}
appendStringInfoChar(dst, '\0');
}
else
appendStringInfoPtr(dst, NULL);
/* session id; non-nullable */
appendStringInfo(dst, "%lx.%x", (long) MyStartTime, MyProcPid);
appendStringInfoChar(dst, '\0');
/* Line number */
{
uint64_t nSeqNum = htobe64(seqNum);
appendBinaryStringInfo(dst, (void *) &nSeqNum, sizeof nSeqNum);
}
/* PS display */
if (MyProcPort)
{
StringInfoData msgbuf;
const char *psdisp;
int displen;
initStringInfo(&msgbuf);
psdisp = get_ps_display(&displen);
appendBinaryStringInfo(&msgbuf, psdisp, displen);
appendStringInfoChar(dst, 'P');
appendStringInfoString(dst, msgbuf.data);
appendStringInfoChar(dst, '\0');
pfree(msgbuf.data);
}
else
appendStringInfoPtr(dst, NULL);
/* session start timestamp */
if (cachedBackendStartTime[0] == '\0')
{
/* Rebuild the cache if it was blown */
reCacheBackendStartTime();
}
/* backend start time; non-nullable string */
appendStringInfoString(dst, cachedBackendStartTime);
appendStringInfoChar(dst, '\0');
/*
* Virtual transaction id
*
* keep VXID format in sync with lockfuncs.c
*/
if (MyProc != NULL && MyProc->backendId != InvalidBackendId)
{
appendStringInfoChar(dst, 'P');
appendStringInfo(dst, "%d/%u", MyProc->backendId, MyProc->lxid);
appendStringInfoChar(dst, '\0');
}
else
appendStringInfoPtr(dst, NULL);
/*
* Transaction id
*
* This seems to be a mistake both here and in elog.c; in particular, it's
* not clear how the epoch would get added here. However, leave room in
* the protocol to fix this later by upcasting.
*/
{
uint64_t nTxid = htobe64((uint64) GetTopTransactionIdIfAny());
appendBinaryStringInfo(dst, (void *) &nTxid, sizeof nTxid);
}
/* Error severity */
{
uint32_t nelevel = htobe32(edata->elevel);
appendBinaryStringInfo(dst, (void *) &nelevel, sizeof nelevel);
}
/* SQL state code */
appendStringInfoPtr(dst, unpack_sql_state(edata->sqlerrcode));
/* errmessage */
appendStringInfoPtr(dst, edata->message);
/* errdetail or errdetail_log */
if (edata->detail_log)
appendStringInfoPtr(dst, edata->detail_log);
else
appendStringInfoPtr(dst, edata->detail);
/* errhint */
appendStringInfoPtr(dst, edata->hint);
/* internal query */
appendStringInfoPtr(dst, edata->internalquery);
/* if printed internal query, print internal pos too */
if (edata->internalpos > 0 && edata->internalquery != NULL)
{
uint32_t ninternalpos = htobe32(edata->internalpos);
appendBinaryStringInfo(dst, (void *) &ninternalpos,
sizeof ninternalpos);
}
else
{
uint32_t ninternalpos = htobe32(-1);
appendBinaryStringInfo(dst, (void *) &ninternalpos,
sizeof ninternalpos);
}
/* errcontext */
appendStringInfoPtr(dst, edata->context);
/*
* user query --- only reported if not disabled by the caller.
*
* Also include query position.
*/
if (isLogLevelOutput(edata->elevel, log_min_error_statement) &&
debug_query_string != NULL && !edata->hide_stmt)
{
uint32_t nCursorPos = htobe32(edata->cursorpos);
appendStringInfoPtr(dst, debug_query_string);
appendBinaryStringInfo(dst, (void *) &nCursorPos, sizeof nCursorPos);
}
else
{
uint32_t nCursorPos = htobe32(-1);
appendStringInfoPtr(dst, NULL);
appendBinaryStringInfo(dst, (void *) &nCursorPos, sizeof nCursorPos);
}
/* file error location */
if (Log_error_verbosity >= PGERROR_VERBOSE)
{
StringInfoData msgbuf;
initStringInfo(&msgbuf);
if (edata->funcname && edata->filename)
appendStringInfo(&msgbuf, "%s, %s:%d",
edata->funcname, edata->filename,
edata->lineno);
else if (edata->filename)
appendStringInfo(&msgbuf, "%s:%d",
edata->filename, edata->lineno);
appendStringInfoChar(dst, 'P');
appendStringInfoString(dst, msgbuf.data);
appendStringInfoChar(dst, '\0');
pfree(msgbuf.data);
}
else
appendStringInfoPtr(dst, NULL);
/* application name */
appendStringInfoPtr(dst, application_name);
}
int
mb_put_int64be(struct mbchain *mbp, int64_t x)
{
x = htobe64(x);
return (mb_put_mem(mbp, (caddr_t)&x, sizeof(x), MB_MSYSTEM));
}
/**
* Verify user name and password
*/
static int otp_verify(const char *vpn_username, const char *vpn_secret)
{
FILE *secrets_file;
user_entry_t user_entry;
otp_params_t otp_params;
const EVP_MD *otp_digest;
char secret[256];
uint8_t decoded_secret[256];
int i;
int ok = 0;
secrets_file = fopen(otp_secrets, "r");
if (NULL == secrets_file) {
LOG("OTP-AUTH: failed to open %s\n", otp_secrets);
return ok;
}
while (!feof(secrets_file)) {
if (read_user_entry(secrets_file, &user_entry)) {
continue;
}
if (strcmp(vpn_username, user_entry.name)) {
continue;
}
/* Handle non-otp passwords before trying to parse out otp fields */
if (!strncasecmp(user_entry.secret, "plain:", sizeof("plain:") - 1)) {
const char *password = user_entry.secret + sizeof("plain:") - 1;
if (vpn_username && !strcmp (vpn_username, user_entry.name)
&& vpn_secret && password && !strcmp (vpn_secret, password)) {
ok = 1;
}
goto done;
}
if (split_secret(user_entry.secret, &otp_params)) {
goto done;
}
otp_digest = EVP_get_digestbyname(otp_params.hash);
if (!otp_digest) {
LOG("OTP-AUTH: unknown digest '%s'\n", otp_params.hash);
goto done;
}
unsigned int key_len;
const void * otp_key;
if (!strcasecmp(otp_params.encoding, "base32")) {
key_len = base32_decode((uint8_t *) otp_params.key, decoded_secret, sizeof(decoded_secret));
otp_key = decoded_secret;
} else
if (!strcasecmp(otp_params.encoding, "hex")) {
key_len = hex_decode(otp_params.key, decoded_secret, sizeof(decoded_secret));
otp_key = decoded_secret;
} else
if (!strcasecmp(otp_params.encoding, "text")) {
otp_key = otp_params.key;
key_len = strlen(otp_params.key);
} else {
LOG("OTP-AUTH: unknown encoding '%s'\n", otp_params.encoding);
goto done;
}
uint64_t T, Tn;
uint8_t mac[EVP_MAX_MD_SIZE];
unsigned maclen;
if (!strncasecmp("totp", otp_params.method, 4)) {
HMAC_CTX hmac;
const uint8_t *otp_bytes;
uint32_t otp, divisor = 1;
int tstep = totp_step;
int tdigits = totp_digits;
if (!strcasecmp("totp-60-6", otp_params.method)) {
tstep = 60;
tdigits = 6;
}
int range = otp_slop / tstep;
T = (time(NULL) - totp_t0) / tstep;
for (i = 0; i < tdigits; ++i) {
divisor *= 10;
}
for (i = -range; !ok && i <= range; ++i) {
Tn = htobe64(T + i);
HMAC_CTX_init(&hmac);
HMAC_Init(&hmac, otp_key, key_len, otp_digest);
HMAC_Update(&hmac, (uint8_t *)&Tn, sizeof(Tn));
HMAC_Final(&hmac, mac, &maclen);
otp_bytes = mac + (mac[maclen - 1] & 0x0f);
otp = ((otp_bytes[0] & 0x7f) << 24) | (otp_bytes[1] << 16) |
(otp_bytes[2] << 8) | otp_bytes[3];
otp %= divisor;
snprintf(secret, sizeof(secret), "%s%0*u", otp_params.pin, tdigits, otp);
if (vpn_username && !strcmp (vpn_username, user_entry.name)
&& vpn_secret && !strcmp (vpn_secret, secret)) {
ok = 1;
}
}
}
else if (!strncasecmp("hotp", otp_params.method, 4)) {
HMAC_CTX hmac;
const uint8_t *otp_bytes;
uint32_t otp, divisor = 1;
int tdigits = totp_digits;
int i = 0;
T = hotp_read_counter(otp_params.key);
for (i = 0; i < tdigits; ++i) {
divisor *= 10;
}
for (i = 0; !ok && i <= hotp_syncwindow; i++) {
Tn = htobe64(T-i);
HMAC_CTX_init(&hmac);
HMAC_Init(&hmac, otp_key, key_len, otp_digest);
HMAC_Update(&hmac, (uint8_t *)&Tn, sizeof(Tn));
HMAC_Final(&hmac, mac, &maclen);
otp_bytes = mac + (mac[maclen - 1] & 0x0f);
otp = ((otp_bytes[0] & 0x7f) << 24) | (otp_bytes[1] << 16) |
(otp_bytes[2] << 8) | otp_bytes[3];
otp %= divisor;
snprintf(secret, sizeof(secret), "%s%0*u", otp_params.pin, tdigits, otp);
if (vpn_username && !strcmp (vpn_username, user_entry.name)
&& vpn_secret && !strcmp (vpn_secret, secret)) {
ok = 1;
hotp_set_counter(otp_params.key, T-i-1);
}
}
}
else if (!strcasecmp("motp", otp_params.method)) {
char buf[64];
int n;
int range = otp_slop / motp_step;
T = time(NULL) / motp_step;
for (i = -range; !ok && i <= range; ++i) {
EVP_MD_CTX ctx;
EVP_MD_CTX_init(&ctx);
EVP_DigestInit_ex(&ctx, otp_digest, NULL);
n = sprintf(buf, "%" PRIu64, T + i);
EVP_DigestUpdate(&ctx, buf, n);
EVP_DigestUpdate(&ctx, otp_key, key_len);
EVP_DigestUpdate(&ctx, otp_params.pin, strlen(otp_params.pin));
if (otp_params.udid) {
int udid_len = strlen(otp_params.udid);
EVP_DigestUpdate(&ctx, otp_params.udid, udid_len);
}
EVP_DigestFinal_ex(&ctx, mac, &maclen);
EVP_MD_CTX_cleanup(&ctx);
snprintf(secret, sizeof(secret),
"%02x%02x%02x", mac[0], mac[1], mac[2]);
if (vpn_username && !strcmp (vpn_username, user_entry.name)
&& vpn_secret && !strcmp (vpn_secret, secret)) {
ok = 1;
}
}
}
else {
LOG("OTP-AUTH: unknown OTP method %s\n", otp_params.method);
}
done:
memset(secret, 0, sizeof(secret));
}
if (NULL != secrets_file) {
fclose(secrets_file);
}
return ok;
}
template <> inline uint64_t host_to <uint64_t, big_endian>(uint64_t value) { return htobe64(value); }
template <> inline int64_t host_to <int64_t, big_endian>(int64_t value) { return (int64_t)htobe64((uint64_t)value); }
int
ikev2_pld_delete(struct iked *env, struct ikev2_payload *pld,
struct iked_message *msg, size_t offset, size_t left)
{
struct iked_childsa **peersas = NULL;
struct iked_sa *sa = msg->msg_sa;
struct ikev2_delete del, *localdel;
struct ibuf *resp = NULL;
u_int64_t *localspi = NULL;
u_int64_t spi64, spi = 0;
u_int32_t spi32;
u_int8_t *buf, *msgbuf = ibuf_data(msg->msg_data);
size_t found = 0, failed = 0;
int cnt, i, len, sz, ret = -1;
/* Skip if it's a response, then we don't have to deal with it */
if (ikev2_msg_frompeer(msg) &&
msg->msg_parent->msg_response)
return (0);
if (ikev2_validate_delete(msg, offset, left, pld, &del))
return (-1);
cnt = betoh16(del.del_nspi);
sz = del.del_spisize;
log_debug("%s: proto %s spisize %d nspi %d",
__func__, print_map(del.del_protoid, ikev2_saproto_map),
sz, cnt);
buf = msgbuf + offset + sizeof(del);
len = betoh16(pld->pld_length) - sizeof(*pld) - sizeof(del);
print_hex(buf, 0, len);
switch (sz) {
case 4:
case 8:
break;
default:
if (del.del_protoid != IKEV2_SAPROTO_IKE) {
log_debug("%s: invalid SPI size", __func__);
return (-1);
}
if (ikev2_msg_frompeer(msg)) {
/* Send an empty informational response */
if ((resp = ibuf_static()) == NULL)
goto done;
ret = ikev2_send_ike_e(env, sa, resp,
IKEV2_PAYLOAD_NONE,
IKEV2_EXCHANGE_INFORMATIONAL, 1);
msg->msg_parent->msg_responded = 1;
ibuf_release(resp);
sa_state(env, sa, IKEV2_STATE_CLOSED);
return (ret);
}
log_debug("%s: invalid SPI size", __func__);
return (ret);
}
if ((len / sz) != cnt) {
log_debug("%s: invalid payload length %d/%d != %d",
__func__, len, sz, cnt);
return (-1);
}
if (ikev2_msg_frompeer(msg) &&
((peersas = calloc(cnt, sizeof(struct iked_childsa *))) == NULL ||
(localspi = calloc(cnt, sizeof(u_int64_t))) == NULL)) {
log_warn("%s", __func__);
goto done;
}
for (i = 0; i < cnt; i++) {
switch (sz) {
case 4:
memcpy(&spi32, buf + (i * sz), sizeof(spi32));
spi = betoh32(spi32);
break;
case 8:
memcpy(&spi64, buf + (i * sz), sizeof(spi64));
spi = betoh64(spi64);
break;
}
log_debug("%s: spi %s", __func__, print_spi(spi, sz));
if (peersas == NULL || sa == NULL)
continue;
if ((peersas[i] = childsa_lookup(sa, spi,
del.del_protoid)) == NULL) {
log_warnx("%s: CHILD SA doesn't exist for spi %s",
__func__, print_spi(spi, del.del_spisize));
continue;
}
if (ikev2_childsa_delete(env, sa, del.del_protoid, spi,
&localspi[i], 0) == -1)
failed++;
else
found++;
/*
* Flows are left in the require mode so that it would be
* possible to quickly negotiate a new Child SA
*/
}
/* Parsed outgoing message? */
if (!ikev2_msg_frompeer(msg))
goto done;
if (msg->msg_parent->msg_response) {
ret = 0;
goto done;
}
/* Response to the INFORMATIONAL with Delete payload */
if ((resp = ibuf_static()) == NULL)
goto done;
if (found) {
if ((localdel = ibuf_advance(resp, sizeof(*localdel))) == NULL)
goto done;
localdel->del_protoid = del.del_protoid;
localdel->del_spisize = del.del_spisize;
localdel->del_nspi = htobe16(found);
for (i = 0; i < cnt; i++) {
switch (sz) {
case 4:
spi32 = htobe32(localspi[i]);
if (ibuf_add(resp, &spi32, sizeof(spi32)) != 0)
goto done;
break;
case 8:
spi64 = htobe64(localspi[i]);
if (ibuf_add(resp, &spi64, sizeof(spi64)) != 0)
goto done;
break;
}
}
log_warnx("%s: deleted %zu spis", __func__, found);
}
if (found) {
ret = ikev2_send_ike_e(env, sa, resp, IKEV2_PAYLOAD_DELETE,
IKEV2_EXCHANGE_INFORMATIONAL, 1);
msg->msg_parent->msg_responded = 1;
} else {
/* XXX should we send an INVALID_SPI notification? */
ret = 0;
}
done:
if (localspi)
free(localspi);
if (peersas)
free(peersas);
ibuf_release(resp);
return (ret);
}
void uint64_to_char_array(uint8_t* dst, const uint64_t data) {
uint64_t* wdst = (uint64_t*)dst;
*wdst = htobe64(data);
}
int main() {
des_ctx_t ctx;
uint64_t i;
uint64_t key;
uint64_t vector[][2] = {
{ 0x8001010101010101, 0x95A8D72813DAA94D },
{ 0x4001010101010101, 0x0EEC1487DD8C26D5 },
{ 0x2001010101010101, 0x7AD16FFB79C45926 },
{ 0x1001010101010101, 0xD3746294CA6A6CF3 },
{ 0x0801010101010101, 0x809F5F873C1FD761 },
{ 0x0401010101010101, 0xC02FAFFEC989D1FC },
{ 0x0201010101010101, 0x4615AA1D33E72F10 },
{ 0x0180010101010101, 0x2055123350C00858 },
{ 0x0140010101010101, 0xDF3B99D6577397C8 },
{ 0x0120010101010101, 0x31FE17369B5288C9 },
{ 0x0110010101010101, 0xDFDD3CC64DAE1642 },
{ 0x0108010101010101, 0x178C83CE2B399D94 },
{ 0x0104010101010101, 0x50F636324A9B7F80 },
{ 0x0102010101010101, 0xA8468EE3BC18F06D },
{ 0x0101800101010101, 0xA2DC9E92FD3CDE92 },
{ 0x0101400101010101, 0xCAC09F797D031287 },
{ 0x0101200101010101, 0x90BA680B22AEB525 },
{ 0x0101100101010101, 0xCE7A24F350E280B6 },
{ 0x0101080101010101, 0x882BFF0AA01A0B87 },
{ 0x0101040101010101, 0x25610288924511C2 },
{ 0x0101020101010101, 0xC71516C29C75D170 },
{ 0x0101018001010101, 0x5199C29A52C9F059 },
{ 0x0101014001010101, 0xC22F0A294A71F29F },
{ 0x0101012001010101, 0xEE371483714C02EA },
{ 0x0101011001010101, 0xA81FBD448F9E522F },
{ 0x0101010801010101, 0x4F644C92E192DFED },
{ 0x0101010401010101, 0x1AFA9A66A6DF92AE },
{ 0x0101010201010101, 0xB3C1CC715CB879D8 },
{ 0x0101010180010101, 0x19D032E64AB0BD8B },
{ 0x0101010140010101, 0x3CFAA7A7DC8720DC },
{ 0x0101010120010101, 0xB7265F7F447AC6F3 },
{ 0x0101010110010101, 0x9DB73B3C0D163F54 },
{ 0x0101010108010101, 0x8181B65BABF4A975 },
{ 0x0101010104010101, 0x93C9B64042EAA240 },
{ 0x0101010102010101, 0x5570530829705592 },
{ 0x0101010101800101, 0x8638809E878787A0 },
{ 0x0101010101400101, 0x41B9A79AF79AC208 },
{ 0x0101010101200101, 0x7A9BE42F2009A892 },
{ 0x0101010101100101, 0x29038D56BA6D2745 },
{ 0x0101010101080101, 0x5495C6ABF1E5DF51 },
{ 0x0101010101040101, 0xAE13DBD561488933 },
{ 0x0101010101020101, 0x024D1FFA8904E389 },
{ 0x0101010101018001, 0xD1399712F99BF02E },
{ 0x0101010101014001, 0x14C1D7C1CFFEC79E },
{ 0x0101010101012001, 0x1DE5279DAE3BED6F },
{ 0x0101010101011001, 0xE941A33F85501303 },
{ 0x0101010101010801, 0xDA99DBBC9A03F379 },
{ 0x0101010101010401, 0xB7FC92F91D8E92E9 },
{ 0x0101010101010201, 0xAE8E5CAA3CA04E85 },
{ 0x0101010101010180, 0x9CC62DF43B6EED74 },
{ 0x0101010101010140, 0xD863DBB5C59A91A0 },
{ 0x0101010101010120, 0xA1AB2190545B91D7 },
{ 0x0101010101010110, 0x0875041E64C570F7 },
{ 0x0101010101010108, 0x5A594528BEBEF1CC },
{ 0x0101010101010104, 0xFCDB3291DE21F0C0 },
{ 0x0101010101010102, 0x869EFD7F9F265A09 }
};
uint64_t x;
for (i = 0; i < (sizeof(vector) / (2 * sizeof(uint64_t))); i++) {
key = vector[i][0];
des3_ecb_init(&ctx, cipher_action_encrypt, key, key, key);
x = htobe64(0);
des_update(&x, &ctx, &x, 8);
x = be64toh(x);
if (x != vector[i][1])
return 1;
}
return 0;
}
static int
write_page_pods(struct adapter *sc, struct toepcb *toep, struct ddp_buffer *db)
{
struct wrqe *wr;
struct ulp_mem_io *ulpmc;
struct ulptx_idata *ulpsc;
struct pagepod *ppod;
int i, j, k, n, chunk, len, ddp_pgsz, idx;
u_int ppod_addr;
uint32_t cmd;
cmd = htobe32(V_ULPTX_CMD(ULP_TX_MEM_WRITE));
if (is_t4(sc))
cmd |= htobe32(F_ULP_MEMIO_ORDER);
else
cmd |= htobe32(F_T5_ULP_MEMIO_IMM);
ddp_pgsz = t4_ddp_pgsz[G_PPOD_PGSZ(db->tag)];
ppod_addr = db->ppod_addr;
for (i = 0; i < db->nppods; ppod_addr += chunk) {
/* How many page pods are we writing in this cycle */
n = min(db->nppods - i, NUM_ULP_TX_SC_IMM_PPODS);
chunk = PPOD_SZ(n);
len = roundup2(sizeof(*ulpmc) + sizeof(*ulpsc) + chunk, 16);
wr = alloc_wrqe(len, toep->ctrlq);
if (wr == NULL)
return (ENOMEM); /* ok to just bail out */
ulpmc = wrtod(wr);
INIT_ULPTX_WR(ulpmc, len, 0, 0);
ulpmc->cmd = cmd;
ulpmc->dlen = htobe32(V_ULP_MEMIO_DATA_LEN(chunk / 32));
ulpmc->len16 = htobe32(howmany(len - sizeof(ulpmc->wr), 16));
ulpmc->lock_addr = htobe32(V_ULP_MEMIO_ADDR(ppod_addr >> 5));
ulpsc = (struct ulptx_idata *)(ulpmc + 1);
ulpsc->cmd_more = htobe32(V_ULPTX_CMD(ULP_TX_SC_IMM));
ulpsc->len = htobe32(chunk);
ppod = (struct pagepod *)(ulpsc + 1);
for (j = 0; j < n; i++, j++, ppod++) {
ppod->vld_tid_pgsz_tag_color = htobe64(F_PPOD_VALID |
V_PPOD_TID(toep->tid) | db->tag);
ppod->len_offset = htobe64(V_PPOD_LEN(db->len) |
V_PPOD_OFST(db->offset));
ppod->rsvd = 0;
idx = i * PPOD_PAGES * (ddp_pgsz / PAGE_SIZE);
for (k = 0; k < nitems(ppod->addr); k++) {
if (idx < db->npages) {
ppod->addr[k] =
htobe64(db->pages[idx]->phys_addr);
idx += ddp_pgsz / PAGE_SIZE;
} else
ppod->addr[k] = 0;
#if 0
CTR5(KTR_CXGBE,
"%s: tid %d ppod[%d]->addr[%d] = %p",
__func__, toep->tid, i, k,
htobe64(ppod->addr[k]));
#endif
}
}
t4_wrq_tx(sc, wr);
}
return (0);
}
int main(int argc, char *argv[])
{
int i;
int j;
char* buffer;
int use_stdout = FALSE;
int skip_invalid = FALSE;
int num_entries = 0;
int verbose = FALSE;
char* file_name_in = 0;
char* file_name_out = 0;
char separator_sign = ' ';
char* parse_string = "xyz";
int64_t global_offset_x = 0;
int64_t global_offset_y = 0;
int check = FALSE;
double scale_x;
double scale_y;
LASReaderH reader = NULL;
LASHeaderH header = NULL;
LASPointH p = NULL;
FILE* file_out;
int len;
unsigned int index = 0;
if (argc == 1) {
usage();
exit(0);
}
for (i = 1; i < argc; i++)
{
if ( strcmp(argv[i],"-h") == 0 ||
strcmp(argv[i],"-help") == 0 ||
strcmp(argv[i],"--help") == 0
)
{
usage();
exit(0);
}
else if ( strcmp(argv[i],"-v") == 0 ||
strcmp(argv[i],"--verbose") == 0
)
{
verbose = TRUE;
}
else if ( strcmp(argv[i],"-s") == 0 ||
strcmp(argv[i],"--skip_invalid") == 0
)
{
skip_invalid = TRUE;
}
else if ( strcmp(argv[i], "--parse") == 0 ||
strcmp(argv[i], "-parse") == 0
)
{
i++;
parse_string = argv[i];
}
else if ( strcmp(argv[i], "--moffset") == 0 ||
strcmp(argv[i], "-moffset") == 0
)
{
i++;
buffer = strtok (argv[i], ",");
j = 0;
while (buffer) {
if (j == 0) {
global_offset_x = S64(buffer);
}
else if (j == 1) {
global_offset_y = S64(buffer);
}
j++;
buffer = strtok (NULL, ",");
while (buffer && *buffer == '\040')
buffer++;
}
if (j != 2){
fprintf(stderr, "Only two int64_t are required in moffset option!\n");
exit(1);
}
}
else if ( strcmp(argv[i], "--check") == 0 ||
strcmp(argv[i], "-check") == 0
)
{
i++;
check = TRUE;
buffer = strtok (argv[i], ",");
j = 0;
while (buffer) {
if (j == 0) {
sscanf(buffer, "%lf", &scale_x);
}
else if (j == 1) {
sscanf(buffer, "%lf", &scale_y);
}
j++;
buffer = strtok (NULL, ",");
while (buffer && *buffer == '\040')
buffer++;
}
if (j != 2){
fprintf(stderr, "Only two doubles are required in moffset option!\n");
exit(1);
}
}
else if ( strcmp(argv[i], "--stdout") == 0
)
{
use_stdout = TRUE;
}
else if ( strcmp(argv[i],"--input") == 0 ||
strcmp(argv[i],"-input") == 0 ||
strcmp(argv[i],"-i") == 0 ||
strcmp(argv[i],"-in") == 0
)
{
i++;
file_name_in = argv[i];
}
else if ( strcmp(argv[i],"--output") == 0 ||
strcmp(argv[i],"--out") == 0 ||
strcmp(argv[i],"-out") == 0 ||
strcmp(argv[i],"-o") == 0
)
{
i++;
file_name_out = argv[i];
}
else if (file_name_in == 0 && file_name_out == 0)
{
file_name_in = argv[i];
}
else if (file_name_in && file_name_out == 0)
{
file_name_out = argv[i];
}
else
{
fprintf(stderr, "ERROR: unknown argument '%s'\n",argv[i]);
usage();
exit(1);
}
} /* end looping through argc/argv */
num_entries = strlen(parse_string);
if (use_stdout == TRUE && file_name_out){
LASError_Print("If an output file is specified, --stdout must not be used!");
exit(1);
}
reader = LASReader_Create(file_name_in);
if (!reader) {
LASError_Print("Unable to read file");
exit(1);
}
header = LASReader_GetHeader(reader);
if (!header) {
LASError_Print("Unable to fetch header for file");
exit(1);
}
if (use_stdout)
{
file_out = stdout;
}
else
{
if (file_name_out == NULL)
{
if (file_name_in == NULL)
{
LASError_Print("No input filename was specified");
usage();
exit(1);
}
len = (int)strlen(file_name_in);
file_name_out = LASCopyString(file_name_in);
if (file_name_out[len-3] == '.' && file_name_out[len-2] == 'g' && file_name_out[len-1] == 'z')
{
len = len - 4;
}
while (len > 0 && file_name_out[len] != '.')
{
len--;
}
file_name_out[len] = '\0';
}
file_out = fopen(file_name_out, "wb");
}
if (file_out == 0)
{
LASError_Print("Could not open file for write");
usage();
exit(1);
}
if (verbose)
{
print_header(stderr, header, file_name_in);
}
// Compute factors to add to X and Y and check sanity of generated codes
double file_scale_x = LASHeader_GetScaleX(header);
double file_scale_y = LASHeader_GetScaleY(header);
if (check)
{
// Check specified scales are like in the LAS file
if (fabs(scale_x - file_scale_x) > TOLERANCE){
fprintf(stderr, "ERROR: x scale in input file (%lf) does not match specified x scale (%lf)\n",file_scale_x, scale_x);
exit(1);
}
if (fabs(scale_y - file_scale_y) > TOLERANCE){
fprintf(stderr, "ERROR: y scale in input file (%lf) does not match specified y scale (%lf)\n",file_scale_y, scale_y);
exit(1);
}
/* Check that the extent of the file (taking into account the global offset)
* is within 0,2^31 */
double check_min_x = 1.0 + LASHeader_GetMinX(header) - (((double) global_offset_x) * scale_x);
if (check_min_x < TOLERANCE) {
fprintf(stderr, "ERROR: Specied X global offset is too large. (MinX - (GlobalX*ScaleX)) < 0\n");
exit(1);
}
double check_min_y = 1.0 + LASHeader_GetMinY(header) - (((double) global_offset_y) * scale_y);
if (check_min_y < TOLERANCE) {
fprintf(stderr, "ERROR: Specied Y global offset is too large. (MinY - (GlobalY*ScaleY)) < 0\n");
exit(1);
}
double check_max_x = LASHeader_GetMaxX(header) - (((double) global_offset_x) * scale_x);
if (check_max_x > (MAX_INT_31 * scale_x)) {
fprintf(stderr, "ERROR: Specied X global offset is too small. (MaxX - (GlobalX*ScaleX)) > (2^31)*ScaleX\n");
exit(1);
}
double check_max_y = LASHeader_GetMaxY(header) - (((double) global_offset_y) * scale_y);
if (check_max_y > (MAX_INT_31 * scale_y)) {
fprintf(stderr, "ERROR: Specied Y global offset is too small. (MaxY - (GlobalY*ScaleY)) > (2^31)*ScaleY\n");
exit(1);
}
}
/*Write Postgres header*/
struct postHeader pgHeader;
pgHeader.s = "PGCOPY\n\377\r\n\0";
int i1T = 0, i2T = 0;
pgHeader.i1 = htonl(i1T);
pgHeader.i2 = htonl(i2T);
fwrite(pgHeader.s, 11, 1, file_out);
fwrite(&pgHeader.i1, sizeof(uint32_t), 1, file_out);
fwrite(&pgHeader.i2, sizeof(uint32_t), 1, file_out);
/* declaration for morton*/
uint32_t rawx = 0;
uint32_t rawy = 0;
uint64_t mortonkey = 0;
/* scaled offsets to add for the morton encoding */
int64_t factorX = ((int64_t) (LASHeader_GetOffsetX(header) / file_scale_x)) - global_offset_x;
int64_t factorY = ((int64_t) (LASHeader_GetOffsetY(header) / file_scale_y)) - global_offset_y;
p = LASReader_GetNextPoint(reader);
while (p)
{
if (skip_invalid && !LASPoint_IsValid(p)) {
if (verbose) {
LASError_Print("Skipping writing invalid point...");
}
p = LASReader_GetNextPoint(reader);
index -=1;
continue;
}
struct postRow pgRow;
uint32_t size;
uint16_t hT = num_entries;
pgRow.h = htons(hT);
fwrite(& pgRow.h, 2, 1, file_out);
size = sizeof(double);
pgRow.vardSize = htonl(size);
size = sizeof(uint32_t);
pgRow.varSize = htonl(size);
i = 0;
for (;;)
{
LASColorH color = LASPoint_GetColor(p);
double vard;
int var;
unsigned long long int vardL, varL;
switch (parse_string[i])
{
/* // the morton code on xy */
case 'k':
rawx = (uint32_t) (((int64_t) LASPoint_GetRawX(p)) + factorX);
rawy = (uint32_t) (((int64_t) LASPoint_GetRawY(p)) + factorY);
mortonkey = EncodeMorton2D(rawx,rawy);
varL = htobe64(mortonkey);
fwrite(&pgRow.vardSize, sizeof(uint32_t), 1, file_out);
fwrite(&varL, sizeof(uint64_t), 1, file_out);
break;
/* // the x coordinate */
case 'x':
vard = LASPoint_GetX(p);
fwrite(&pgRow.vardSize, sizeof(uint32_t), 1, file_out);
vardL = bigEndian_double(vard);
fwrite(&vardL, sizeof(double), 1, file_out);
break;
/* // the y coordinate */
case 'y':
vard = LASPoint_GetY(p);
fwrite(&pgRow.vardSize, sizeof(uint32_t), 1, file_out);
vardL = bigEndian_double(vard);
fwrite(&vardL, sizeof(double), 1, file_out);
break;
/* // the z coordinate */
case 'z':
vard = LASPoint_GetZ(p);
fwrite(&pgRow.vardSize, sizeof(uint32_t), 1, file_out);
vardL = bigEndian_double(vard);
fwrite(&vardL, sizeof(double), 1, file_out);
break;
/* // the gps-time */
case 't':
vard = LASPoint_GetTime(p);
fwrite(&pgRow.vardSize, sizeof(uint32_t), 1, file_out);
vardL = bigEndian_double(vard);
fwrite(&vardL, sizeof(double), 1, file_out);
break;
/* // the intensity */
case 'i':
var = LASPoint_GetIntensity(p);
fwrite(&pgRow.varSize, sizeof(uint32_t), 1, file_out);
varL = htonl(var);
fwrite(&varL, sizeof(uint32_t), 1, file_out);
break;
/* the scan angle */
case 'a':
var = LASPoint_GetScanAngleRank(p);
fwrite(&pgRow.varSize, sizeof(uint32_t), 1, file_out);
varL = htonl(var);
fwrite(&varL, sizeof(uint32_t), 1, file_out);
break;
/* the number of the return */
case 'r':
var = LASPoint_GetReturnNumber(p);
fwrite(&pgRow.varSize, sizeof(uint32_t), 1, file_out);
varL = htonl(var);
fwrite(&varL, sizeof(uint32_t), 1, file_out);
break;
/* the classification */
case 'c':
var = LASPoint_GetClassification(p);
fwrite(&pgRow.varSize, sizeof(uint32_t), 1, file_out);
varL = htonl(var);
fwrite(&varL, sizeof(uint32_t), 1, file_out);
break;
/* the user data */
case 'u':
var = LASPoint_GetUserData(p);
fwrite(&pgRow.varSize, sizeof(uint32_t), 1, file_out);
varL = htonl(var);
fwrite(&varL, sizeof(uint32_t), 1, file_out);
break;
/* the number of returns of given pulse */
case 'n':
var = LASPoint_GetNumberOfReturns(p);
fwrite(&pgRow.varSize, sizeof(uint32_t), 1, file_out);
varL = htonl(var);
fwrite(&varL, sizeof(uint32_t), 1, file_out);
break;
/* the red channel color */
case 'R':
var = LASColor_GetRed(color);
fwrite(&pgRow.varSize, sizeof(uint32_t), 1, file_out);
varL = htonl(var);
fwrite(&varL, sizeof(uint32_t), 1, file_out);
break;
/* the green channel color */
case 'G':
var = LASColor_GetGreen(color);
fwrite(&pgRow.varSize, sizeof(uint32_t), 1, file_out);
varL = htonl(var);
fwrite(&varL, sizeof(uint32_t), 1, file_out);
break;
/* the blue channel color */
case 'B':
var = LASColor_GetBlue(color);
fwrite(&pgRow.varSize, sizeof(uint32_t), 1, file_out);
varL = htonl(var);
fwrite(&varL, sizeof(uint32_t), 1, file_out);
break;
case 'M':
var = index;
fwrite(&pgRow.varSize, sizeof(uint32_t), 1, file_out);
varL = htonl(var);
fwrite(&varL, sizeof(uint32_t), 1, file_out);
break;
case 'p':
var = LASPoint_GetPointSourceId(p);
fwrite(&pgRow.varSize, sizeof(uint32_t), 1, file_out);
varL = htonl(var);
fwrite(&varL, sizeof(uint32_t), 1, file_out);
break;
/* the edge of flight line flag */
case 'e':
var = LASPoint_GetFlightLineEdge(p);
fwrite(&pgRow.varSize, sizeof(uint32_t), 1, file_out);
varL = htonl(var);
fwrite(&varL, sizeof(uint32_t), 1, file_out);
break;
/* the direction of scan flag */
case 'd':
var = LASPoint_GetScanDirection(p);
fwrite(&pgRow.varSize, sizeof(uint32_t), 1, file_out);
varL = htonl(var);
fwrite(&varL, sizeof(uint32_t), 1, file_out);
break;
}
i++;
if (!parse_string[i])
{
break;
}
LASColor_Destroy(color);
}
p = LASReader_GetNextPoint(reader);
index +=1;
}
short endT = -1;
short end = htons(endT);
fwrite(&end, sizeof(end), 1, file_out);
fflush(file_out);
fclose(file_out);
LASReader_Destroy(reader);
LASHeader_Destroy(header);
return 0;
}