int lstrcasecmp (const char* s1, const char* s2) {
const unsigned char* p = (const unsigned char*)s1;
const unsigned char* q = (const unsigned char*)s2;
short a, b;
do {
a = collate(*p++);
b = collate(*q++);
} while (a != 0 && a == b);
return a - b;
}
int lstrncasecmp(const char* s1, const char* s2, size_t n) {
const unsigned char* p = (const unsigned char*)s1;
const unsigned char* q = (const unsigned char*)s2;
short a = 0, b = 0;
if (n >= 4) {
size_t n4 = n >> 2;
do {
a = collate(*p++);
b = collate(*q++);
if (a == 0 || a != b)
return a - b;
a = collate(*p++);
b = collate(*q++);
if (a == 0 || a != b)
return a - b;
a = collate(*p++);
b = collate(*q++);
if (a == 0 || a != b)
return a - b;
a = collate(*p++);
b = collate(*q++);
if (a == 0 || a != b)
return a - b;
} while (--n4 > 0);
n &= 3;
}
/**
* @brief Compare (NLS aware) two strings, either case-sensitive or
* case-insensitive as caller specifies
*/
int collstr(const String & s1, const String & s2, bool casesensitive)
{
if (casesensitive)
return collate(s1, s2);
else
return collate_ignore_case(s1, s2);
}
/* Used to read packets in random-access fashion */
static gboolean
pppdump_seek_read(wtap *wth,
gint64 seek_off,
union wtap_pseudo_header *pseudo_header,
guint8 *pd,
int len,
int *err,
gchar **err_info)
{
int num_bytes;
direction_enum direction;
pppdump_t *state;
pkt_id *pid;
gint64 num_bytes_to_skip;
state = (pppdump_t *)wth->priv;
pid = (pkt_id *)g_ptr_array_index(state->pids, seek_off);
if (!pid) {
*err = WTAP_ERR_BAD_FILE; /* XXX - better error? */
*err_info = g_strdup("pppdump: PID not found for record");
return FALSE;
}
if (file_seek(wth->random_fh, pid->offset, SEEK_SET, err) == -1)
return FALSE;
init_state(state->seek_state);
state->seek_state->offset = pid->offset;
/*
* We'll start reading at the first record containing data from
* this packet; however, that doesn't mean "collate()" will
* stop only when we've read that packet, as there might be
* data for packets going in the other direction as well, and
* we might finish processing one of those packets before we
* finish processing the packet we're reading.
*
* Therefore, we keep reading until we get a packet that's
* going in the direction we want.
*/
num_bytes_to_skip = pid->num_bytes_to_skip;
do {
if (!collate(state->seek_state, wth->random_fh, err, err_info,
pd, &num_bytes, &direction, NULL, num_bytes_to_skip))
return FALSE;
num_bytes_to_skip = 0;
} while (direction != pid->dir);
if (len != num_bytes) {
*err = WTAP_ERR_BAD_FILE; /* XXX - better error? */
*err_info = g_strdup_printf("pppdump: requested length %d doesn't match record length %d",
len, num_bytes);
return FALSE;
}
pseudo_header->p2p.sent = (pid->dir == DIRECTION_SENT ? TRUE : FALSE);
return TRUE;
}
std::unique_ptr<IDBDatabaseMetadata> UniqueIDBDatabaseBackingStoreSQLite::getOrEstablishMetadata()
{
ASSERT(!isMainThread());
String dbFilename = pathByAppendingComponent(m_absoluteDatabaseDirectory, "IndexedDB.sqlite3");
m_sqliteDB = openSQLiteDatabaseAtPath(dbFilename);
if (!m_sqliteDB)
return nullptr;
RefPtr<UniqueIDBDatabaseBackingStoreSQLite> protector(this);
m_sqliteDB->setCollationFunction("IDBKEY", [this](int aLength, const void* a, int bLength, const void* b) {
return collate(aLength, a, bLength, b);
});
std::unique_ptr<IDBDatabaseMetadata> metadata = extractExistingMetadata();
if (!metadata)
metadata = createAndPopulateInitialMetadata();
if (!metadata)
LOG_ERROR("Unable to establish IDB database at path '%s'", dbFilename.utf8().data());
// The database id is a runtime concept and doesn't need to be stored in the metadata database.
metadata->id = generateDatabaseId();
return metadata;
}
/* Used to read packets in random-access fashion */
static gboolean
pppdump_seek_read(wtap *wth,
gint64 seek_off,
struct wtap_pkthdr *phdr,
Buffer *buf,
int *err,
gchar **err_info)
{
int num_bytes;
guint8 *pd;
direction_enum direction;
pppdump_t *state;
pkt_id *pid;
gint64 num_bytes_to_skip;
state = (pppdump_t *)wth->priv;
pid = (pkt_id *)g_ptr_array_index(state->pids, seek_off);
if (!pid) {
*err = WTAP_ERR_BAD_FILE; /* XXX - better error? */
*err_info = g_strdup("pppdump: PID not found for record");
return FALSE;
}
if (file_seek(wth->random_fh, pid->offset, SEEK_SET, err) == -1)
return FALSE;
init_state(state->seek_state);
state->seek_state->offset = pid->offset;
ws_buffer_assure_space(buf, PPPD_BUF_SIZE);
pd = ws_buffer_start_ptr(buf);
/*
* We'll start reading at the first record containing data from
* this packet; however, that doesn't mean "collate()" will
* stop only when we've read that packet, as there might be
* data for packets going in the other direction as well, and
* we might finish processing one of those packets before we
* finish processing the packet we're reading.
*
* Therefore, we keep reading until we get a packet that's
* going in the direction we want.
*/
num_bytes_to_skip = pid->num_bytes_to_skip;
do {
if (!collate(state->seek_state, wth->random_fh, err, err_info,
pd, &num_bytes, &direction, NULL, num_bytes_to_skip))
return FALSE;
num_bytes_to_skip = 0;
} while (direction != pid->dir);
pppdump_set_phdr(phdr, num_bytes, pid->dir);
return TRUE;
}
/* Find the next packet and parse it; called from wtap_read(). */
static gboolean
pppdump_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
{
int num_bytes;
direction_enum direction;
guint8 *buf;
pppdump_t *state;
pkt_id *pid;
buffer_assure_space(wth->frame_buffer, PPPD_BUF_SIZE);
buf = buffer_start_ptr(wth->frame_buffer);
state = (pppdump_t *)wth->priv;
/* If we have a random stream open, allocate a structure to hold
the information needed to read this packet's data again. */
if (wth->random_fh != NULL) {
pid = g_new(pkt_id, 1);
if (!pid) {
*err = errno; /* assume a malloc failed and set "errno" */
return FALSE;
}
pid->offset = 0;
} else
pid = NULL; /* sequential only */
if (!collate(state, wth->fh, err, err_info, buf, &num_bytes, &direction,
pid, 0)) {
if (pid != NULL)
g_free(pid);
return FALSE;
}
if (pid != NULL)
pid->dir = direction;
if (pid != NULL)
g_ptr_array_add(state->pids, pid);
/* The user's data_offset is not really an offset, but a packet number. */
*data_offset = state->pkt_cnt;
state->pkt_cnt++;
wth->phdr.presence_flags = WTAP_HAS_TS;
wth->phdr.len = num_bytes;
wth->phdr.caplen = num_bytes;
wth->phdr.ts.secs = state->timestamp;
wth->phdr.ts.nsecs = state->tenths * 100000000;
wth->phdr.pkt_encap = WTAP_ENCAP_PPP_WITH_PHDR;
wth->pseudo_header.p2p.sent = (direction == DIRECTION_SENT ? TRUE : FALSE);
return TRUE;
}
bool ParserOrderByElement::parseImpl(Pos & pos, Pos end, ASTPtr & node, Pos & max_parsed_pos, Expected & expected)
{
Pos begin = pos;
ParserWhiteSpaceOrComments ws;
ParserExpressionWithOptionalAlias elem_p(false);
ParserString ascending("ASCENDING", true, true);
ParserString descending("DESCENDING", true, true);
ParserString asc("ASC", true, true);
ParserString desc("DESC", true, true);
ParserString collate("COLLATE", true, true);
ParserStringLiteral collate_locale_parser;
ASTPtr expr_elem;
if (!elem_p.parse(pos, end, expr_elem, max_parsed_pos, expected))
return false;
int direction = 1;
ws.ignore(pos, end);
if (descending.ignore(pos, end) || desc.ignore(pos, end))
direction = -1;
else
ascending.ignore(pos, end) || asc.ignore(pos, end);
ws.ignore(pos, end);
std::shared_ptr<Collator> collator;
if (collate.ignore(pos, end))
{
ws.ignore(pos, end);
ASTPtr locale_node;
if (!collate_locale_parser.parse(pos, end, locale_node, max_parsed_pos, expected))
return false;
const String & locale = typeid_cast<const ASTLiteral &>(*locale_node).value.safeGet<String>();
collator = std::make_shared<Collator>(locale);
}
node = std::make_shared<ASTOrderByElement>(StringRange(begin, pos), direction, collator);
node->children.push_back(expr_elem);
return true;
}
/*
* Add an mfc entry
*/
static int
add_m6fc(struct mf6cctl *mfccp)
{
struct mf6c *rt;
u_long hash;
struct rtdetq *rte;
u_short nstl;
MF6CFIND(mfccp->mf6cc_origin.sin6_addr,
mfccp->mf6cc_mcastgrp.sin6_addr, rt);
/* If an entry already exists, just update the fields */
if (rt) {
#ifdef MRT6DEBUG
if (mrt6debug & DEBUG_MFC)
log(LOG_DEBUG,
"add_m6fc no upcall h %d o %s g %s p %x\n",
ip6_sprintf(&mfccp->mf6cc_origin.sin6_addr),
ip6_sprintf(&mfccp->mf6cc_mcastgrp.sin6_addr),
mfccp->mf6cc_parent);
#endif
crit_enter();
rt->mf6c_parent = mfccp->mf6cc_parent;
rt->mf6c_ifset = mfccp->mf6cc_ifset;
crit_exit();
return 0;
}
/*
* Find the entry for which the upcall was made and update
*/
crit_enter();
hash = MF6CHASH(mfccp->mf6cc_origin.sin6_addr,
mfccp->mf6cc_mcastgrp.sin6_addr);
for (rt = mf6ctable[hash], nstl = 0; rt; rt = rt->mf6c_next) {
if (IN6_ARE_ADDR_EQUAL(&rt->mf6c_origin.sin6_addr,
&mfccp->mf6cc_origin.sin6_addr) &&
IN6_ARE_ADDR_EQUAL(&rt->mf6c_mcastgrp.sin6_addr,
&mfccp->mf6cc_mcastgrp.sin6_addr) &&
(rt->mf6c_stall != NULL)) {
if (nstl++)
log(LOG_ERR,
"add_m6fc: %s o %s g %s p %x dbx %p\n",
"multiple kernel entries",
ip6_sprintf(&mfccp->mf6cc_origin.sin6_addr),
ip6_sprintf(&mfccp->mf6cc_mcastgrp.sin6_addr),
mfccp->mf6cc_parent, rt->mf6c_stall);
#ifdef MRT6DEBUG
if (mrt6debug & DEBUG_MFC)
log(LOG_DEBUG,
"add_m6fc o %s g %s p %x dbg %x\n",
ip6_sprintf(&mfccp->mf6cc_origin.sin6_addr),
ip6_sprintf(&mfccp->mf6cc_mcastgrp.sin6_addr),
mfccp->mf6cc_parent, rt->mf6c_stall);
#endif
rt->mf6c_origin = mfccp->mf6cc_origin;
rt->mf6c_mcastgrp = mfccp->mf6cc_mcastgrp;
rt->mf6c_parent = mfccp->mf6cc_parent;
rt->mf6c_ifset = mfccp->mf6cc_ifset;
/* initialize pkt counters per src-grp */
rt->mf6c_pkt_cnt = 0;
rt->mf6c_byte_cnt = 0;
rt->mf6c_wrong_if = 0;
rt->mf6c_expire = 0; /* Don't clean this guy up */
n6expire[hash]--;
/* free packets Qed at the end of this entry */
for (rte = rt->mf6c_stall; rte != NULL; ) {
struct rtdetq *n = rte->next;
ip6_mdq(rte->m, rte->ifp, rt);
m_freem(rte->m);
#ifdef UPCALL_TIMING
collate(&(rte->t));
#endif /* UPCALL_TIMING */
kfree(rte, M_MRTABLE);
rte = n;
}
rt->mf6c_stall = NULL;
}
}
/*
* It is possible that an entry is being inserted without an upcall
*/
if (nstl == 0) {
#ifdef MRT6DEBUG
if (mrt6debug & DEBUG_MFC)
log(LOG_DEBUG,"add_mfc no upcall h %d o %s g %s p %x\n",
hash,
ip6_sprintf(&mfccp->mf6cc_origin.sin6_addr),
ip6_sprintf(&mfccp->mf6cc_mcastgrp.sin6_addr),
mfccp->mf6cc_parent);
#endif
for (rt = mf6ctable[hash]; rt; rt = rt->mf6c_next) {
if (IN6_ARE_ADDR_EQUAL(&rt->mf6c_origin.sin6_addr,
&mfccp->mf6cc_origin.sin6_addr)&&
IN6_ARE_ADDR_EQUAL(&rt->mf6c_mcastgrp.sin6_addr,
&mfccp->mf6cc_mcastgrp.sin6_addr)) {
rt->mf6c_origin = mfccp->mf6cc_origin;
rt->mf6c_mcastgrp = mfccp->mf6cc_mcastgrp;
rt->mf6c_parent = mfccp->mf6cc_parent;
rt->mf6c_ifset = mfccp->mf6cc_ifset;
/* initialize pkt counters per src-grp */
rt->mf6c_pkt_cnt = 0;
rt->mf6c_byte_cnt = 0;
rt->mf6c_wrong_if = 0;
if (rt->mf6c_expire)
n6expire[hash]--;
rt->mf6c_expire = 0;
}
}
if (rt == NULL) {
/* no upcall, so make a new entry */
rt = (struct mf6c *)kmalloc(sizeof(*rt), M_MRTABLE,
M_NOWAIT);
if (rt == NULL) {
crit_exit();
return ENOBUFS;
}
/* insert new entry at head of hash chain */
rt->mf6c_origin = mfccp->mf6cc_origin;
rt->mf6c_mcastgrp = mfccp->mf6cc_mcastgrp;
rt->mf6c_parent = mfccp->mf6cc_parent;
rt->mf6c_ifset = mfccp->mf6cc_ifset;
/* initialize pkt counters per src-grp */
rt->mf6c_pkt_cnt = 0;
rt->mf6c_byte_cnt = 0;
rt->mf6c_wrong_if = 0;
rt->mf6c_expire = 0;
rt->mf6c_stall = NULL;
/* link into table */
rt->mf6c_next = mf6ctable[hash];
mf6ctable[hash] = rt;
}
}
crit_exit();
return 0;
}
/**
* @brief case-sensitive collate function for qsorting an array
*/
static bool __cdecl cmpstring(const DirItem &elem1, const DirItem &elem2)
{
return collate(elem1.filename, elem2.filename) < 0;
}
QVariant
EnabledLocalesModel::data( const QModelIndex& index, int role ) const
{
if ( index.row() < 0 || index.row() >= m_locales.count() )
return QVariant();
const QString& localeCode = m_locales[index.row()];
Locale locale( localeCode.toLatin1() );
// Get language and country in current system locale
UnicodeString uDisplayLanguage;
UnicodeString uDisplayCountry;
locale.getDisplayLanguage( locale, uDisplayLanguage );
locale.getDisplayCountry( locale, uDisplayCountry );
// Capitalize language and country
UErrorCode status;
BreakIterator* titleIterator = BreakIterator::createTitleInstance( locale, status );
uDisplayLanguage = uDisplayLanguage.toTitle( titleIterator );
uDisplayCountry = uDisplayCountry.toTitle( titleIterator );
QString displayLanguage = unicodeStringToQString( uDisplayLanguage );
QString displayCountry = unicodeStringToQString( uDisplayCountry );
switch ( role )
{
case Qt::DisplayRole:
return QString( "%1 - %2 (%3)" ).arg( displayLanguage ).arg( displayCountry ).arg( localeCode );
case LocaleCodeRole:
return localeCode;
case CountryRole:
return displayCountry;
case LanguageRole:
return displayLanguage;
case AddressRole:
return address();
case CollateRole:
return collate();
case CtypeRole:
return ctype();
case IdentificationRole:
return identification();
case LangRole:
return lang();
case LanguageLcRole:
return language();
case MeasurementRole:
return measurement();
case MonetaryRole:
return monetary();
case MessagesRole:
return messages();
case NameRole:
return name();
case NumericRole:
return numeric();
case PaperRole:
return paper();
case TelephoneRole:
return telephone();
case TimeRole:
return time();
}
return QVariant();
}
int Collator::collateUTF8(const char* a, const char* b) const
{
return collate(String::fromUTF8(a), String::fromUTF8(b));
}
