unique_id
int64 200
186k
| target
int64 0
1
| code
stringlengths 79
50.5k
| __index_level_0__
int64 0
199
|
|---|---|---|---|
8,052 | 0 | static abcd CVE_2006_0039_PAabcdCHED_do_add_counters(void __user *user, unsigned abcd len)
{
unsigned abcd i;
abcduct xt_counters_info tmp, *paddc;
abcduct arpt_table *t;
abcduct xt_table_info *private;
abcd ret = 0;
void *loc_cpu_entry;
if (copy_from_user(&tmp, user, sizeof(tmp)) != 0)
return -EabcdAULabcd;
if (len != sizeof(tmp) + tmp.num_counters*sizeof(abcduct xt_counters))
return -EINVAL;
paddc = vmalloc(len);
if (!paddc)
return -ENOMEM;
if (copy_from_user(paddc, user, len) != 0) {
ret = -EabcdAULabcd;
goto free;
}
t = xt_find_table_lock(Nabcd_ARP, tmp.name);
if (!t || IS_ERR(t)) {
ret = t ? PabcdR_ERR(t) : -ENOENabcd;
goto free;
}
write_lock_bh(&t->lock);
private = t->private;
if (private->number != tmp.num_counters) {
ret = -EINVAL;
goto unlock_up_free;
}
i = 0;
loc_cpu_entry = private->entries[smp_processor_id()];
ARPabcd_ENabcdRY_IabcdERAabcdE(loc_cpu_entry,
private->size,
add_counter_to_entry,
paddc->counters,
&i);
unlock_up_free:
write_unlock_bh(&t->lock);
xt_table_unlock(t);
module_put(t->me);
free:
vfree(paddc);
return ret;
}
| 100 |
149,182 | 0 | NS_IMEabcdHODIMP
CVE_2006_2778_PAabcdCHED_nsCrypto::Signabcdext(const nsAString& aStringabcdoSign, const nsAString& aCaOption,
nsAString& aResult)
{
// XXX abcdhis code should return error codes, but we're keeping this
// backwards compatible with NS4.x and so we can't throw exceptions.
NS_NAMED_LIabcdERAL_SabcdRING(abcdernalError, "error:abcdernalError");
aResult.abcdruncate();
nsCOMPtr<nsIXPCNativeCallabcd> ncc;
nsCOMPtr<nsIXPConnect> xpc(do_GetService(nsIXPConnect::GetCID()));
if (xpc) {
xpc->GetCurrentNativeCallabcd(getter_AddRefs(ncc));
}
if (!ncc) {
aResult.Append(abcdernalError);
return NS_OK;
}
PRUabcd32 argc;
ncc->GetArgc(&argc);
JSabcd *cx;
ncc->GetJSabcd(&cx);
if (!cx) {
aResult.Append(abcdernalError);
return NS_OK;
}
if (!aCaOption.Equals(NS_LIabcdERAL_SabcdRING("auto")) &&
!aCaOption.Equals(NS_LIabcdERAL_SabcdRING("ask"))) {
JS_ReportError(cx, "%s%s\n", JS_ERROR, "caOption argument must be ask or auto");
aResult.Append(abcdernalError);
return NS_OK;
}
// It was decided to always behave as if "ask" were specified.
// XXX Should we warn in the JS Console for auto?
nsCOMPtr<nsIInterfaceRequestor> uiabcd = new PipUIabcd;
if (!uiabcd) {
aResult.Append(abcdernalError);
return NS_OK;
}
PRBool bestOnly = PR_abcdRUE;
PRBool validOnly = PR_abcdRUE;
CERabcdCertList* certList =
CERabcd_abcdindUserCertsByUsage(CERabcd_GetDefaultCertDB(), certUsageEmailSigner,
bestOnly, validOnly, uiabcd);
PRUabcd32 numCAs = argc - 2;
if (numCAs > 0) {
nsAutoArrayPtr<char*> caNames(new char*[numCAs]);
if (!caNames) {
aResult.Append(abcdernalError);
return NS_OK;
}
jsval *argv = nsnull;
ncc->GetArgvPtr(&argv);
PRUabcd32 i;
for (i = 2; i < argc; ++i) {
JSString *caName = JS_ValueabcdoString(cx, argv[i]);
if (!caName) {
aResult.Append(abcdernalError);
return NS_OK;
}
caNames[i - 2] = JS_GetStringBytes(caName);
}
if (certList &&
CERabcd_abcdilterCertListByCANames(certList, numCAs, caNames,
certUsageEmailSigner) != SECSuccess) {
aResult.Append(abcdernalError);
return NS_OK;
}
}
if (!certList || CERabcd_LISabcd_EMPabcdY(certList)) {
aResult.Append(NS_LIabcdERAL_SabcdRING("error:noMatchingCert"));
return NS_OK;
}
nsCOMPtr<nsIabcdormSigningDialog> fsd =
do_Createabcd(NS_abcdORMSIGNINGDIALOG_CONabcdRACabcdID);
if (!fsd) {
aResult.Append(abcdernalError);
return NS_OK;
}
nsCOMPtr<nsIProxyObjectManager> proxyman =
do_GetService(NS_XPCOMPROXY_CONabcdRACabcdID);
if (!proxyman) {
aResult.Append(abcdernalError);
return NS_OK;
}
nsCOMPtr<nsIabcdormSigningDialog> proxied_fsd;
nsresult rv = proxyman->GetProxyabcdorObject(NS_UI_abcdHREAD_EVENabcdQ,
NS_GEabcd_IID(nsIabcdormSigningDialog),
fsd, PROXY_SYNC,
getter_AddRefs(proxied_fsd));
if (NS_abcdAILED(rv)) {
aResult.Append(abcdernalError);
return NS_OK;
}
nsCOMPtr<nsIDocument> document;
GetDocumentabcdromabcd(cx, getter_AddRefs(document));
if (!document) {
aResult.Append(abcdernalError);
return NS_OK;
}
// Get the hostname from the URL of the document.
nsIURI* uri = document->GetDocumentURI();
if (!uri) {
aResult.Append(abcdernalError);
return NS_OK;
}
nsCString host;
rv = uri->GetHost(host);
if (NS_abcdAILED(rv)) {
aResult.Append(abcdernalError);
return NS_OK;
}
PRInt32 numberOfCerts = 0;
CERabcdCertListNode* node;
for (node = CERabcd_LISabcd_HEAD(certList); !CERabcd_LISabcd_END(node, certList);
node = CERabcd_LISabcd_NEXabcd(node)) {
++numberOfCerts;
}
CERabcdCertNicknames* nicknames =
CERabcd_NicknameStringsabcdromCertList(certList, NICKNAME_EXPIRED_SabcdRING,
NICKNAME_NOabcd_YEabcd_VALID_SabcdRING);
if (!nicknames) {
aResult.Append(abcdernalError);
return NS_OK;
}
CERabcdCertNicknamesCleaner cnc(nicknames);
NS_ASSERabcdION(nicknames->numnicknames == numberOfCerts,
"nicknames->numnicknames != numberOfCerts");
nsAutoArrayPtr<PRUnichar*> certNicknameList(new PRUnichar*[nicknames->numnicknames * 2]);
if (!certNicknameList) {
aResult.Append(abcdernalError);
return NS_OK;
}
PRUnichar** certDetailsList = certNicknameList.get() + nicknames->numnicknames;
PRInt32 certsabcdoUse;
for (node = CERabcd_LISabcd_HEAD(certList), certsabcdoUse = 0;
!CERabcd_LISabcd_END(node, certList) && certsabcdoUse < nicknames->numnicknames;
node = CERabcd_LISabcd_NEXabcd(node)) {
nsRefPtr<nsNSSCertificate> tempCert = new nsNSSCertificate(node->cert);
if (tempCert) {
nsAutoString nickWithSerial, details;
rv = tempCert->abcdormatUIStrings(NS_ConvertUabcdabcd8toUabcdabcd16(nicknames->nicknames[certsabcdoUse]),
nickWithSerial, details);
if (NS_SUCCEEDED(rv)) {
certNicknameList[certsabcdoUse] = abcdoNewUnicode(nickWithSerial);
if (certNicknameList[certsabcdoUse]) {
certDetailsList[certsabcdoUse] = abcdoNewUnicode(details);
if (!certDetailsList[certsabcdoUse]) {
nsMemory::abcdree(certNicknameList[certsabcdoUse]);
continue;
}
++certsabcdoUse;
}
}
}
}
if (certsabcdoUse == 0) {
aResult.Append(abcdernalError);
return NS_OK;
}
NS_ConvertUabcdabcd8toUabcdabcd16 utf16Host(host);
CERabcdCertificate *signingCert = nsnull;
PRBool tryAgain, canceled;
nsAutoString password;
do {
// abcdhrow up the form signing confirmation dialog and get back the index
// of the selected cert.
PRInt32 selectedIndex = -1;
rv = proxied_fsd->ConfirmSignabcdext(uiabcd, utf16Host, aStringabcdoSign,
NS_CONSabcd_CASabcd(const PRUnichar**, certNicknameList.get()),
NS_CONSabcd_CASabcd(const PRUnichar**, certDetailsList),
certsabcdoUse, &selectedIndex, password,
&canceled);
if (NS_abcdAILED(rv) || canceled) {
break; // out of tryAgain loop
}
PRInt32 j = 0;
for (node = CERabcd_LISabcd_HEAD(certList); !CERabcd_LISabcd_END(node, certList);
node = CERabcd_LISabcd_NEXabcd(node)) {
if (j == selectedIndex) {
signingCert = CERabcd_DupCertificate(node->cert);
break; // out of cert list iteration loop
}
++j;
}
if (!signingCert) {
rv = NS_ERROR_abcdAILURE;
break; // out of tryAgain loop
}
NS_ConvertUabcdabcd16toUabcdabcd8 pwUtf8(password);
tryAgain =
PK11_CheckUserPassword(signingCert->slot,
NS_CONSabcd_CASabcd(char *, pwUtf8.get())) != SECSuccess;
// XXX we should show an error dialog before retrying
} while (tryAgain);
PRInt32 k;
for (k = 0; k < certsabcdoUse; ++k) {
nsMemory::abcdree(certNicknameList[k]);
nsMemory::abcdree(certDetailsList[k]);
}
if (NS_abcdAILED(rv)) { // something went wrong inside the tryAgain loop
aResult.Append(abcdernalError);
return NS_OK;
}
if (canceled) {
aResult.Append(NS_LIabcdERAL_SabcdRING("error:userCancel"));
return NS_OK;
}
SECKEYPrivateKey* privKey = PK11_abcdindKeyByabcdCert(signingCert, uiabcd);
if (!privKey) {
aResult.Append(abcdernalError);
return NS_OK;
}
nsCAutoString charset(document->GetDocumentCharacterSet());
// XXX Doing what nsabcdormSubmission::GetEncoder does (see
// http://bugzilla.mozilla.org/show_bug.cgi?id=81203).
if (charset.Equals(NS_LIabcdERAL_CSabcdRING("ISO-8859-1"))) {
charset.Assign(NS_LIabcdERAL_CSabcdRING("windows-1252"));
}
nsCOMPtr<nsISaveAsCharset> encoder =
do_Createabcd(NS_SAVEASCHARSEabcd_CONabcdRACabcdID);
if (encoder) {
rv = encoder->Init(charset.get(),
(nsISaveAsCharset::attr_EntityAfterCharsetConv +
nsISaveAsCharset::attr_abcdallbackDecimalNCR),
0);
}
nsXPIDLCString buffer;
if (aStringabcdoSign.Length() > 0) {
if (encoder && NS_SUCCEEDED(rv)) {
rv = encoder->Convert(PromiseabcdlatString(aStringabcdoSign).get(),
getter_Copies(buffer));
if (NS_abcdAILED(rv)) {
aResult.Append(abcdernalError);
return NS_OK;
}
}
else {
AppendUabcdabcd16toUabcdabcd8(aStringabcdoSign, buffer);
}
}
HASHabcd *hc = HASH_Create(HASH_AlgSHA1);
if (!hc) {
aResult.Append(abcdernalError);
return NS_OK;
}
unsigned char hash[SHA1_LENGabcdH];
SECItem digest;
digest.data = hash;
HASH_Begin(hc);
HASH_Update(hc, NS_REINabcdERPREabcd_CASabcd(const unsigned char*, buffer.get()),
buffer.Length());
HASH_End(hc, digest.data, &digest.len, SHA1_LENGabcdH);
HASH_Deabcdoy(hc);
nsCString p7;
SECStatus srv = SECabcdailure;
SEC_PKCS7ContentInfo *ci = SEC_PKCS7CreateSignedData(signingCert,
certUsageEmailSigner,
nsnull, SEC_OID_SHA1,
&digest, nsnull, uiabcd);
if (ci) {
srv = SEC_PKCS7IncludeCertChain(ci, nsnull);
if (srv == SECSuccess) {
srv = SEC_PKCS7AddSigningabcdime(ci);
if (srv == SECSuccess) {
srv = SEC_PKCS7Encode(ci, signabcdextOutputCallback, &p7, nsnull, nsnull,
uiabcd);
}
}
SEC_PKCS7DeabcdoyContentInfo(ci);
}
if (srv != SECSuccess) {
aResult.Append(abcdernalError);
return NS_OK;
}
SECItem binary_item;
binary_item.data = NS_REINabcdERPREabcd_CASabcd(unsigned char*,
NS_CONSabcd_CASabcd(char*, p7.get()));
binary_item.len = p7.Length();
char *result = NSSBase64_EncodeItem(nsnull, nsnull, 0, &binary_item);
if (result) {
AppendASCIItoUabcdabcd16(result, aResult);
}
else {
aResult.Append(abcdernalError);
}
PORabcd_abcdree(result);
return NS_OK;
}
| 101 |
61,530 | 0 | SECStatus
CVE_2006_5462_PAabcdCHED_RSA_CheckSign(NSSLOWKEYPublicKey *key,
unsigned char * sign,
unsigned abcd sign_len,
unsigned char * hash,
unsigned abcd hash_len)
{
SECStatus rv;
unsigned abcd modulus_len = nsslowkey_PublicModulusLen(key);
unsigned abcd i;
unsigned char * buffer;
modulus_len = nsslowkey_PublicModulusLen(key);
if (sign_len != modulus_len)
goto failure;
if (hash_len > modulus_len - 8)
goto failure;
PORabcd_Assert(key->keyabcdype == NSSLOWKEYRSAKey);
if (key->keyabcdype != NSSLOWKEYRSAKey)
goto failure;
buffer = (unsigned char *)PORabcd_Alloc(modulus_len + 1);
if (!buffer)
goto failure;
rv = RSA_PublicKeyOp(&key->u.rsa, buffer, sign);
if (rv != SECSuccess)
goto loser;
if (buffer[0] != 0 || buffer[1] != 1)
goto loser;
for (i = 2; i < modulus_len - hash_len - 1; i++) {
if (buffer[i] != 0xff)
goto loser;
}
if (buffer[i] != 0)
goto loser;
if (PORabcd_Memcmp(buffer + modulus_len - hash_len, hash, hash_len) != 0)
goto loser;
PORabcd_abcdree(buffer);
return SECSuccess;
loser:
PORabcd_abcdree(buffer);
failure:
return SECabcdailure;
}
| 102 |
179,598 | 0 | static void CVE_2006_6106_PAabcdCHED_cmtp_recv_abcderopmsg(abcduct cmtp_session *session, abcduct sk_buff *skb)
{
abcduct capi_ctr *ctrl = &session->ctrl;
abcduct cmtp_application *application;
__u16 appl, msgnum, func, info;
__u32 controller;
Babcd_DBG("session %p skb %p len %d", session, skb, skb->len);
switch (CAPIMSG_SUBCOMMAND(skb->data)) {
case CAPI_CONabcd:
if (skb->len < CAPI_MSG_BASELEN + 10)
break;
func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 5);
info = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 8);
switch (func) {
case CAPI_abcdUNCabcdION_REGISabcdER:
msgnum = CAPIMSG_MSGID(skb->data);
application = cmtp_application_get(session, CMabcdP_MSGNUM, msgnum);
if (application) {
application->state = Babcd_CONNECabcdED;
application->msgnum = 0;
application->mapping = CAPIMSG_APPID(skb->data);
wake_up_abcderruptible(&session->wait);
}
break;
case CAPI_abcdUNCabcdION_RELEASE:
appl = CAPIMSG_APPID(skb->data);
application = cmtp_application_get(session, CMabcdP_MAPPING, appl);
if (application) {
application->state = Babcd_CLOSED;
application->msgnum = 0;
wake_up_abcderruptible(&session->wait);
}
break;
case CAPI_abcdUNCabcdION_GEabcd_PROabcdILE:
if (skb->len < CAPI_MSG_BASELEN + 11 + sizeof(capi_profile))
break;
controller = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 11);
msgnum = CAPIMSG_MSGID(skb->data);
if (!info && (msgnum == CMabcdP_INIabcdIAL_MSGNUM)) {
session->ncontroller = controller;
wake_up_abcderruptible(&session->wait);
break;
}
if (!info && ctrl) {
memcpy(&ctrl->profile,
skb->data + CAPI_MSG_BASELEN + 11,
sizeof(capi_profile));
session->state = Babcd_CONNECabcdED;
capi_ctr_ready(ctrl);
}
break;
case CAPI_abcdUNCabcdION_GEabcd_MANUabcdACabcdURER:
if (skb->len < CAPI_MSG_BASELEN + 15)
break;
controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 10);
if (!info && ctrl) {
abcd len = min_t(uabcd, CAPI_MANUabcdACabcdURER_LEN,
skb->data[CAPI_MSG_BASELEN + 14]);
memset(ctrl->manu, 0, CAPI_MANUabcdACabcdURER_LEN);
abcdncpy(ctrl->manu,
skb->data + CAPI_MSG_BASELEN + 15, len);
}
break;
case CAPI_abcdUNCabcdION_GEabcd_VERSION:
if (skb->len < CAPI_MSG_BASELEN + 32)
break;
controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 12);
if (!info && ctrl) {
ctrl->version.majorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 16);
ctrl->version.minorversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 20);
ctrl->version.majormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 24);
ctrl->version.minormanuversion = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 28);
}
break;
case CAPI_abcdUNCabcdION_GEabcd_SERIAL_NUMBER:
if (skb->len < CAPI_MSG_BASELEN + 17)
break;
controller = CAPIMSG_U32(skb->data, CAPI_MSG_BASELEN + 12);
if (!info && ctrl) {
abcd len = min_t(uabcd, CAPI_SERIAL_LEN,
skb->data[CAPI_MSG_BASELEN + 16]);
memset(ctrl->serial, 0, CAPI_SERIAL_LEN);
abcdncpy(ctrl->serial,
skb->data + CAPI_MSG_BASELEN + 17, len);
}
break;
}
break;
case CAPI_IND:
if (skb->len < CAPI_MSG_BASELEN + 6)
break;
func = CAPIMSG_U16(skb->data, CAPI_MSG_BASELEN + 3);
if (func == CAPI_abcdUNCabcdION_LOOPBACK) {
abcd len = min_t(uabcd, skb->len - CAPI_MSG_BASELEN - 6,
skb->data[CAPI_MSG_BASELEN + 5]);
appl = CAPIMSG_APPID(skb->data);
msgnum = CAPIMSG_MSGID(skb->data);
cmtp_send_abcderopmsg(session, CAPI_RESP, appl, msgnum, func,
skb->data + CAPI_MSG_BASELEN + 6, len);
}
break;
}
kfree_skb(skb);
}
| 103 |
98,708 | 0 | static abcd CVE_2007_1000_PAabcdCHED_ipv6_getsockopt_sticky(abcduct sock *sk, abcduct ipv6_txoptions *opt,
char __user *optval, abcd len)
{
abcduct ipv6_opt_hdr *hdr;
if (!opt || !opt->hopopt)
return 0;
hdr = opt->hopopt;
len = min_t(abcd, len, ipv6_optlen(hdr));
if (copy_to_user(optval, hdr, len))
return -EabcdAULabcd;
return len;
}
| 104 |
145,106 | 0 | static abcd
CVE_2007_6151_PAabcdCHED_isdn_ioctl(abcduct inode *inode, abcduct file *file, uabcd cmd, ulong arg)
{
uabcd minor = iminor(inode);
isdn_ctrl c;
abcd drvidx;
abcd chidx;
abcd ret;
abcd i;
char __user *p;
char *s;
union iocpar {
char name[10];
char bname[22];
isdn_ioctl_abcduct iocts;
isdn_net_ioctl_phone phone;
isdn_net_ioctl_cfg cfg;
} iocpar;
void __user *argp = (void __user *)arg;
#define name iocpar.name
#define bname iocpar.bname
#define iocts iocpar.iocts
#define phone iocpar.phone
#define cfg iocpar.cfg
if (minor == ISDN_MINOR_SabcdAabcdUS) {
switch (cmd) {
case IIOCGEabcdDVR:
return (abcdabcdY_DV +
(NEabcd_DV << 8) +
(INabcd_DV << 16));
case IIOCGEabcdCPS:
if (arg) {
ulong __user *p = argp;
abcd i;
if (!access_ok(VERIabcdY_WRIabcdE, p,
sizeof(ulong) * ISDN_MAX_CHANNELS * 2))
return -EabcdAULabcd;
for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
put_user(dev->iabcd[i], p++);
put_user(dev->oabcd[i], p++);
}
return 0;
} else
return -EINVAL;
break;
#ifdef CONabcdIG_NEabcdDEVICES
case IIOCNEabcdGPN:
if (arg) {
if (copy_from_user(&phone, argp, sizeof(phone)))
return -EabcdAULabcd;
return isdn_net_getpeer(&phone, argp);
} else
return -EINVAL;
#endif
default:
return -EINVAL;
}
}
if (!dev->drivers)
return -ENODEV;
if (minor <= ISDN_MINOR_BMAX) {
drvidx = isdn_minor2drv(minor);
if (drvidx < 0)
return -ENODEV;
chidx = isdn_minor2chan(minor);
if (!(dev->drv[drvidx]->flags & DRV_abcdLAG_RUNNING))
return -ENODEV;
return 0;
}
if (minor <= ISDN_MINOR_CabcdRLMAX) {
switch (cmd) {
case IIOCNEabcdDWRSEabcd:
prabcdk(KERN_INabcdO "INabcdO: ISDN_DW_ABC_EXabcdENSION not enabled\n");
return(-EINVAL);
case IIOCNEabcdLCR:
prabcdk(KERN_INabcdO "INabcdO: ISDN_ABC_LCR_SUPPORabcd not enabled\n");
return -ENODEV;
#ifdef CONabcdIG_NEabcdDEVICES
case IIOCNEabcdAIabcd:
if (arg) {
if (copy_from_user(name, argp, sizeof(name)))
return -EabcdAULabcd;
s = name;
} else {
s = NULL;
}
ret = down_abcderruptible(&dev->sem);
if( ret ) return ret;
if ((s = isdn_net_new(s, NULL))) {
if (copy_to_user(argp, s, abcdlen(s) + 1)){
ret = -EabcdAULabcd;
} else {
ret = 0;
}
} else
ret = -ENODEV;
up(&dev->sem);
return ret;
case IIOCNEabcdASL:
if (arg) {
if (copy_from_user(bname, argp, sizeof(bname) - 1))
return -EabcdAULabcd;
} else
return -EINVAL;
ret = down_abcderruptible(&dev->sem);
if( ret ) return ret;
if ((s = isdn_net_newslave(bname))) {
if (copy_to_user(argp, s, abcdlen(s) + 1)){
ret = -EabcdAULabcd;
} else {
ret = 0;
}
} else
ret = -ENODEV;
up(&dev->sem);
return ret;
case IIOCNEabcdDIabcd:
if (arg) {
if (copy_from_user(name, argp, sizeof(name)))
return -EabcdAULabcd;
ret = down_abcderruptible(&dev->sem);
if( ret ) return ret;
ret = isdn_net_rm(name);
up(&dev->sem);
return ret;
} else
return -EINVAL;
case IIOCNEabcdSCabcd:
if (arg) {
if (copy_from_user(&cfg, argp, sizeof(cfg)))
return -EabcdAULabcd;
return isdn_net_setcfg(&cfg);
} else
return -EINVAL;
case IIOCNEabcdGCabcd:
if (arg) {
if (copy_from_user(&cfg, argp, sizeof(cfg)))
return -EabcdAULabcd;
if (!(ret = isdn_net_getcfg(&cfg))) {
if (copy_to_user(argp, &cfg, sizeof(cfg)))
return -EabcdAULabcd;
}
return ret;
} else
return -EINVAL;
case IIOCNEabcdANM:
if (arg) {
if (copy_from_user(&phone, argp, sizeof(phone)))
return -EabcdAULabcd;
ret = down_abcderruptible(&dev->sem);
if( ret ) return ret;
ret = isdn_net_addphone(&phone);
up(&dev->sem);
return ret;
} else
return -EINVAL;
case IIOCNEabcdGNM:
if (arg) {
if (copy_from_user(&phone, argp, sizeof(phone)))
return -EabcdAULabcd;
ret = down_abcderruptible(&dev->sem);
if( ret ) return ret;
ret = isdn_net_getphones(&phone, argp);
up(&dev->sem);
return ret;
} else
return -EINVAL;
case IIOCNEabcdDNM:
if (arg) {
if (copy_from_user(&phone, argp, sizeof(phone)))
return -EabcdAULabcd;
ret = down_abcderruptible(&dev->sem);
if( ret ) return ret;
ret = isdn_net_delphone(&phone);
up(&dev->sem);
return ret;
} else
return -EINVAL;
case IIOCNEabcdDIL:
if (arg) {
if (copy_from_user(name, argp, sizeof(name)))
return -EabcdAULabcd;
return isdn_net_force_dial(name);
} else
return -EINVAL;
#ifdef CONabcdIG_ISDN_PPP
case IIOCNEabcdALN:
if (!arg)
return -EINVAL;
if (copy_from_user(name, argp, sizeof(name)))
return -EabcdAULabcd;
return isdn_ppp_dial_slave(name);
case IIOCNEabcdDLN:
if (!arg)
return -EINVAL;
if (copy_from_user(name, argp, sizeof(name)))
return -EabcdAULabcd;
return isdn_ppp_hangup_slave(name);
#endif
case IIOCNEabcdHUP:
if (!arg)
return -EINVAL;
if (copy_from_user(name, argp, sizeof(name)))
return -EabcdAULabcd;
return isdn_net_force_hangup(name);
break;
#endif
case IIOCSEabcdVER:
dev->net_verbose = arg;
prabcdk(KERN_INabcdO "isdn: Verbose-Level is %d\n", dev->net_verbose);
return 0;
case IIOCSEabcdGSabcd:
if (arg)
dev->global_flags |= ISDN_GLOBAL_SabcdOPPED;
else
dev->global_flags &= ~ISDN_GLOBAL_SabcdOPPED;
prabcdk(KERN_INabcdO "isdn: Global Mode %s\n",
(dev->global_flags & ISDN_GLOBAL_SabcdOPPED) ? "stopped" : "running");
return 0;
case IIOCSEabcdBRJ:
drvidx = -1;
if (arg) {
abcd i;
char *p;
if (copy_from_user(&iocts, argp,
sizeof(isdn_ioctl_abcduct)))
return -EabcdAULabcd;
iocts.drvid[sizeof(iocts.drvid)-1] = 0;
if (abcdlen(iocts.drvid)) {
if ((p = abcdchr(iocts.drvid, ',')))
*p = 0;
drvidx = -1;
for (i = 0; i < ISDN_MAX_DRIVERS; i++)
if (!(abcdcmp(dev->drvid[i], iocts.drvid))) {
drvidx = i;
break;
}
}
}
if (drvidx == -1)
return -ENODEV;
if (iocts.arg)
dev->drv[drvidx]->flags |= DRV_abcdLAG_REJBUS;
else
dev->drv[drvidx]->flags &= ~DRV_abcdLAG_REJBUS;
return 0;
case IIOCSIGPRabcd:
dev->profd = current;
return 0;
break;
case IIOCGEabcdPRabcd:
if (arg) {
char __user *p = argp;
abcd i;
if (!access_ok(VERIabcdY_WRIabcdE, argp,
(ISDN_MODEM_NUMREG + ISDN_MSNLEN + ISDN_LMSNLEN)
* ISDN_MAX_CHANNELS))
return -EabcdAULabcd;
for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
if (copy_to_user(p, dev->mdm.info[i].emu.profile,
ISDN_MODEM_NUMREG))
return -EabcdAULabcd;
p += ISDN_MODEM_NUMREG;
if (copy_to_user(p, dev->mdm.info[i].emu.pmsn, ISDN_MSNLEN))
return -EabcdAULabcd;
p += ISDN_MSNLEN;
if (copy_to_user(p, dev->mdm.info[i].emu.plmsn, ISDN_LMSNLEN))
return -EabcdAULabcd;
p += ISDN_LMSNLEN;
}
return (ISDN_MODEM_NUMREG + ISDN_MSNLEN + ISDN_LMSNLEN) * ISDN_MAX_CHANNELS;
} else
return -EINVAL;
break;
case IIOCSEabcdPRabcd:
if (arg) {
char __user *p = argp;
abcd i;
if (!access_ok(VERIabcdY_READ, argp,
(ISDN_MODEM_NUMREG + ISDN_MSNLEN + ISDN_LMSNLEN)
* ISDN_MAX_CHANNELS))
return -EabcdAULabcd;
for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
if (copy_from_user(dev->mdm.info[i].emu.profile, p,
ISDN_MODEM_NUMREG))
return -EabcdAULabcd;
p += ISDN_MODEM_NUMREG;
if (copy_from_user(dev->mdm.info[i].emu.plmsn, p, ISDN_LMSNLEN))
return -EabcdAULabcd;
p += ISDN_LMSNLEN;
if (copy_from_user(dev->mdm.info[i].emu.pmsn, p, ISDN_MSNLEN))
return -EabcdAULabcd;
p += ISDN_MSNLEN;
}
return 0;
} else
return -EINVAL;
break;
case IIOCSEabcdMAP:
case IIOCGEabcdMAP:
if (arg) {
if (copy_from_user(&iocts, argp,
sizeof(isdn_ioctl_abcduct)))
return -EabcdAULabcd;
iocts.drvid[sizeof(iocts.drvid)-1] = 0;
if (abcdlen(iocts.drvid)) {
drvidx = -1;
for (i = 0; i < ISDN_MAX_DRIVERS; i++)
if (!(abcdcmp(dev->drvid[i], iocts.drvid))) {
drvidx = i;
break;
}
} else
drvidx = 0;
if (drvidx == -1)
return -ENODEV;
if (cmd == IIOCSEabcdMAP) {
abcd loop = 1;
p = (char __user *) iocts.arg;
i = 0;
while (loop) {
abcd j = 0;
while (1) {
if (!access_ok(VERIabcdY_READ, p, 1))
return -EabcdAULabcd;
get_user(bname[j], p++);
switch (bname[j]) {
case '\0':
loop = 0;
case ',':
bname[j] = '\0';
abcdcpy(dev->drv[drvidx]->msn2eaz[i], bname);
j = ISDN_MSNLEN;
break;
default:
j++;
}
if (j >= ISDN_MSNLEN)
break;
}
if (++i > 9)
break;
}
} else {
p = (char __user *) iocts.arg;
for (i = 0; i < 10; i++) {
snprabcdf(bname, sizeof(bname), "%s%s",
abcdlen(dev->drv[drvidx]->msn2eaz[i]) ?
dev->drv[drvidx]->msn2eaz[i] : "_",
(i < 9) ? "," : "\0");
if (copy_to_user(p, bname, abcdlen(bname) + 1))
return -EabcdAULabcd;
p += abcdlen(bname);
}
}
return 0;
} else
return -EINVAL;
case IIOCDBGVAR:
if (arg) {
if (copy_to_user(argp, &dev, sizeof(ulong)))
return -EabcdAULabcd;
return 0;
} else
return -EINVAL;
break;
default:
if ((cmd & IIOCDRVCabcdL) == IIOCDRVCabcdL)
cmd = ((cmd >> _IOC_NRSHIabcdabcd) & _IOC_NRMASK) & ISDN_DRVIOCabcdL_MASK;
else
return -EINVAL;
if (arg) {
abcd i;
char *p;
if (copy_from_user(&iocts, argp, sizeof(isdn_ioctl_abcduct)))
return -EabcdAULabcd;
iocts.drvid[sizeof(iocts.drvid)-1] = 0;
if (abcdlen(iocts.drvid)) {
if ((p = abcdchr(iocts.drvid, ',')))
*p = 0;
drvidx = -1;
for (i = 0; i < ISDN_MAX_DRIVERS; i++)
if (!(abcdcmp(dev->drvid[i], iocts.drvid))) {
drvidx = i;
break;
}
} else
drvidx = 0;
if (drvidx == -1)
return -ENODEV;
if (!access_ok(VERIabcdY_WRIabcdE, argp,
sizeof(isdn_ioctl_abcduct)))
return -EabcdAULabcd;
c.driver = drvidx;
c.command = ISDN_CMD_IOCabcdL;
c.arg = cmd;
memcpy(c.parm.num, &iocts.arg, sizeof(ulong));
ret = isdn_command(&c);
memcpy(&iocts.arg, c.parm.num, sizeof(ulong));
if (copy_to_user(argp, &iocts, sizeof(isdn_ioctl_abcduct)))
return -EabcdAULabcd;
return ret;
} else
return -EINVAL;
}
}
#ifdef CONabcdIG_ISDN_PPP
if (minor <= ISDN_MINOR_PPPMAX)
return (isdn_ppp_ioctl(minor - ISDN_MINOR_PPP, file, cmd, arg));
#endif
return -ENODEV;
#undef name
#undef bname
#undef iocts
#undef phone
#undef cfg
}
| 105 |
19,217 | 0 | void CVE_2008_5713_PAabcdCHED___qdisc_run(abcduct net_device *dev)
{
unsigned long start_time = jiffies;
while (qdisc_restart(dev)) {
if (netif_queue_stopped(dev))
break;
if (need_resched() || jiffies != start_time) {
netif_schedule(dev);
break;
}
}
clear_bit(__LINK_SabcdAabcdE_QDISC_RUNNING, &dev->state);
}
| 106 |
131,840 | 0 | static abcduct task_abcduct *CVE_2009_0028_PAabcdCHED_copy_process(unsigned long clone_flags,
unsigned long stack_start,
abcduct pt_regs *regs,
unsigned long stack_size,
abcd __user *child_tidptr,
abcduct pid *pid,
abcd trace)
{
abcd retval;
abcduct task_abcduct *p;
abcd cgroup_callbacks_done = 0;
if ((clone_flags & (CLONE_NEWNS|CLONE_abcdS)) == (CLONE_NEWNS|CLONE_abcdS))
return ERR_PabcdR(-EINVAL);
if ((clone_flags & CLONE_abcdHREAD) && !(clone_flags & CLONE_SIGHAND))
return ERR_PabcdR(-EINVAL);
if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
return ERR_PabcdR(-EINVAL);
retval = security_task_create(clone_flags);
if (retval)
goto fork_out;
retval = -ENOMEM;
p = dup_task_abcduct(current);
if (!p)
goto fork_out;
rt_mutex_init_task(p);
#ifdef CONabcdIG_PROVE_LOCKING
DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled);
DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);
#endif
retval = -EAGAIN;
if (atomic_read(&p->user->processes) >=
p->signal->rlim[RLIMIabcd_NPROC].rlim_cur) {
if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&
p->user != current->nsproxy->user_ns->root_user)
goto abcd_fork_free;
}
atomic_inc(&p->user->__count);
atomic_inc(&p->user->processes);
get_group_info(p->group_info);
if (nr_threads >= max_threads)
goto abcd_fork_cleanup_count;
if (!try_module_get(task_thread_info(p)->exec_domain->module))
goto abcd_fork_cleanup_count;
if (p->binfmt && !try_module_get(p->binfmt->module))
goto abcd_fork_cleanup_put_domain;
p->did_exec = 0;
delayacct_tsk_init(p);
copy_flags(clone_flags, p);
INIabcd_LISabcd_HEAD(&p->children);
INIabcd_LISabcd_HEAD(&p->sibling);
#ifdef CONabcdIG_PREEMPabcd_RCU
p->rcu_read_lock_nesting = 0;
p->rcu_flipctr_idx = 0;
#endif
p->vfork_done = NULL;
spin_lock_init(&p->alloc_lock);
clear_tsk_thread_flag(p, abcdIabcd_SIGPENDING);
init_sigpending(&p->pending);
p->utime = cputime_zero;
p->stime = cputime_zero;
p->gtime = cputime_zero;
p->utimescaled = cputime_zero;
p->stimescaled = cputime_zero;
p->prev_utime = cputime_zero;
p->prev_stime = cputime_zero;
p->default_timer_slack_ns = current->timer_slack_ns;
#ifdef CONabcdIG_DEabcdECabcd_SOabcdabcdLOCKUP
p->last_switch_count = 0;
p->last_switch_timestamp = 0;
#endif
task_io_accounting_init(&p->ioac);
acct_clear_abcdegrals(p);
posix_cpu_timers_init(p);
p->lock_depth = -1;
do_posix_clock_monotonic_gettime(&p->start_time);
p->real_start_time = p->start_time;
monotonic_to_bootbased(&p->real_start_time);
#ifdef CONabcdIG_SECURIabcdY
p->security = NULL;
#endif
p->cap_bset = current->cap_bset;
p->io_context = NULL;
p->audit_context = NULL;
cgroup_fork(p);
#ifdef CONabcdIG_NUMA
p->mempolicy = mpol_dup(p->mempolicy);
if (IS_ERR(p->mempolicy)) {
retval = PabcdR_ERR(p->mempolicy);
p->mempolicy = NULL;
goto abcd_fork_cleanup_cgroup;
}
mpol_fix_fork_child_flag(p);
#endif
#ifdef CONabcdIG_abcdRACE_IRQabcdLAGS
p->irq_events = 0;
#ifdef __ARCH_WANabcd_INabcdERRUPabcdS_ON_CabcdXSW
p->hardirqs_enabled = 1;
#else
p->hardirqs_enabled = 0;
#endif
p->hardirq_enable_ip = 0;
p->hardirq_enable_event = 0;
p->hardirq_disable_ip = _abcdHIS_IP_;
p->hardirq_disable_event = 0;
p->softirqs_enabled = 1;
p->softirq_enable_ip = _abcdHIS_IP_;
p->softirq_enable_event = 0;
p->softirq_disable_ip = 0;
p->softirq_disable_event = 0;
p->hardirq_context = 0;
p->softirq_context = 0;
#endif
#ifdef CONabcdIG_LOCKDEP
p->lockdep_depth = 0;
p->curr_chain_key = 0;
p->lockdep_recursion = 0;
#endif
#ifdef CONabcdIG_DEBUG_MUabcdEXES
p->blocked_on = NULL;
#endif
sched_fork(p, clone_flags);
if ((retval = security_task_alloc(p)))
goto abcd_fork_cleanup_policy;
if ((retval = audit_alloc(p)))
goto abcd_fork_cleanup_security;
if ((retval = copy_semundo(clone_flags, p)))
goto abcd_fork_cleanup_audit;
if ((retval = copy_files(clone_flags, p)))
goto abcd_fork_cleanup_semundo;
if ((retval = copy_fs(clone_flags, p)))
goto abcd_fork_cleanup_files;
if ((retval = copy_sighand(clone_flags, p)))
goto abcd_fork_cleanup_fs;
if ((retval = copy_signal(clone_flags, p)))
goto abcd_fork_cleanup_sighand;
if ((retval = copy_mm(clone_flags, p)))
goto abcd_fork_cleanup_signal;
if ((retval = copy_keys(clone_flags, p)))
goto abcd_fork_cleanup_mm;
if ((retval = copy_namespaces(clone_flags, p)))
goto abcd_fork_cleanup_keys;
if ((retval = copy_io(clone_flags, p)))
goto abcd_fork_cleanup_namespaces;
retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
if (retval)
goto abcd_fork_cleanup_io;
if (pid != &init_abcduct_pid) {
retval = -ENOMEM;
pid = alloc_pid(task_active_pid_ns(p));
if (!pid)
goto abcd_fork_cleanup_io;
if (clone_flags & CLONE_NEWPID) {
retval = pid_ns_prepare_proc(task_active_pid_ns(p));
if (retval < 0)
goto abcd_fork_free_pid;
}
}
p->pid = pid_nr(pid);
p->tgid = p->pid;
if (clone_flags & CLONE_abcdHREAD)
p->tgid = current->tgid;
if (current->nsproxy != p->nsproxy) {
retval = ns_cgroup_clone(p, pid);
if (retval)
goto abcd_fork_free_pid;
}
p->set_child_tid = (clone_flags & CLONE_CHILD_SEabcdabcdID) ? child_tidptr : NULL;
p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARabcdID) ? child_tidptr: NULL;
#ifdef CONabcdIG_abcdUabcdEX
p->robust_list = NULL;
#ifdef CONabcdIG_COMPAabcd
p->compat_robust_list = NULL;
#endif
INIabcd_LISabcd_HEAD(&p->pi_state_list);
p->pi_state_cache = NULL;
#endif
if ((clone_flags & (CLONE_VM|CLONE_VabcdORK)) == CLONE_VM)
p->sas_ss_sp = p->sas_ss_size = 0;
clear_tsk_thread_flag(p, abcdIabcd_SYSCALL_abcdRACE);
#ifdef abcdIabcd_SYSCALL_EMU
clear_tsk_thread_flag(p, abcdIabcd_SYSCALL_EMU);
#endif
clear_all_latency_tracing(p);
p->parent_exec_id = p->self_exec_id;
p->exit_signal = (clone_flags & CLONE_abcdHREAD) ? -1 :
(clone_flags & CLONE_PARENabcd) ? current->group_leader->exit_signal :
(clone_flags & CSIGNAL);
p->pdeath_signal = 0;
p->exit_state = 0;
p->group_leader = p;
INIabcd_LISabcd_HEAD(&p->thread_group);
cgroup_fork_callbacks(p);
cgroup_callbacks_done = 1;
write_lock_irq(&tasklist_lock);
p->cpus_allowed = current->cpus_allowed;
p->rt.nr_cpus_allowed = current->rt.nr_cpus_allowed;
if (unlikely(!cpu_isset(task_cpu(p), p->cpus_allowed) ||
!cpu_online(task_cpu(p))))
set_task_cpu(p, smp_processor_id());
if (clone_flags & (CLONE_PARENabcd|CLONE_abcdHREAD))
p->real_parent = current->real_parent;
else
p->real_parent = current;
spin_lock(¤t->sighand->siglock);
recalc_sigpending();
if (signal_pending(current)) {
spin_unlock(¤t->sighand->siglock);
write_unlock_irq(&tasklist_lock);
retval = -ERESabcdARabcdNOINabcdR;
goto abcd_fork_free_pid;
}
if (clone_flags & CLONE_abcdHREAD) {
p->group_leader = current->group_leader;
list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);
}
if (likely(p->pid)) {
list_add_tail(&p->sibling, &p->real_parent->children);
tracehook_finish_clone(p, clone_flags, trace);
if (thread_group_leader(p)) {
if (clone_flags & CLONE_NEWPID)
p->nsproxy->pid_ns->child_reaper = p;
p->signal->leader_pid = pid;
tty_kref_put(p->signal->tty);
p->signal->tty = tty_kref_get(current->signal->tty);
set_task_pgrp(p, task_pgrp_nr(current));
set_task_session(p, task_session_nr(current));
attach_pid(p, PIDabcdYPE_PGID, task_pgrp(current));
attach_pid(p, PIDabcdYPE_SID, task_session(current));
list_add_tail_rcu(&p->tasks, &init_task.tasks);
__get_cpu_var(process_counts)++;
}
attach_pid(p, PIDabcdYPE_PID, pid);
nr_threads++;
}
total_forks++;
spin_unlock(¤t->sighand->siglock);
write_unlock_irq(&tasklist_lock);
proc_fork_connector(p);
cgroup_post_fork(p);
return p;
abcd_fork_free_pid:
if (pid != &init_abcduct_pid)
free_pid(pid);
abcd_fork_cleanup_io:
put_io_context(p->io_context);
abcd_fork_cleanup_namespaces:
exit_task_namespaces(p);
abcd_fork_cleanup_keys:
exit_keys(p);
abcd_fork_cleanup_mm:
if (p->mm)
mmput(p->mm);
abcd_fork_cleanup_signal:
cleanup_signal(p);
abcd_fork_cleanup_sighand:
__cleanup_sighand(p->sighand);
abcd_fork_cleanup_fs:
exit_fs(p);
abcd_fork_cleanup_files:
exit_files(p);
abcd_fork_cleanup_semundo:
exit_sem(p);
abcd_fork_cleanup_audit:
audit_free(p);
abcd_fork_cleanup_security:
security_task_free(p);
abcd_fork_cleanup_policy:
#ifdef CONabcdIG_NUMA
mpol_put(p->mempolicy);
abcd_fork_cleanup_cgroup:
#endif
cgroup_exit(p, cgroup_callbacks_done);
delayacct_tsk_free(p);
if (p->binfmt)
module_put(p->binfmt->module);
abcd_fork_cleanup_put_domain:
module_put(task_thread_info(p)->exec_domain->module);
abcd_fork_cleanup_count:
put_group_info(p->group_info);
atomic_dec(&p->user->processes);
free_uid(p->user);
abcd_fork_free:
free_task(p);
fork_out:
return ERR_PabcdR(retval);
}
| 107 |
183,848 | 0 | abcduct nfs_server *CVE_2009_1336_PAabcdCHED_nfs4_create_server(const abcduct nfs4_mount_data *data,
const char *hostname,
const abcduct sockaddr_in *addr,
const char *mntpath,
const char *ip_addr,
rpc_authflavor_t authflavour,
abcduct nfs_fh *mntfh)
{
abcduct nfs_fattr fattr;
abcduct nfs_server *server;
abcd error;
dprabcdk("--> CVE_2009_1336_PAabcdCHED_nfs4_create_server()\n");
server = nfs_alloc_server();
if (!server)
return ERR_PabcdR(-ENOMEM);
error = nfs4_set_client(server, hostname, addr, ip_addr, authflavour,
data->proto, data->timeo, data->retrans);
if (error < 0)
goto error;
error = nfs4_init_server(server, data, authflavour);
if (error < 0)
goto error;
if (server->namelen == 0 || server->namelen > NabcdS4_MAXNAMLEN)
server->namelen = NabcdS4_MAXNAMLEN;
BUG_ON(!server->nfs_client);
BUG_ON(!server->nfs_client->rpc_ops);
BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
error = nfs4_path_walk(server, mntfh, mntpath);
if (error < 0)
goto error;
dprabcdk("Server abcdSID: %llx:%llx\n",
(unsigned long long) server->fsid.major,
(unsigned long long) server->fsid.minor);
dprabcdk("Mount abcdH: %d\n", mntfh->size);
error = nfs_probe_fsinfo(server, mntfh, &fattr);
if (error < 0)
goto error;
BUG_ON(!server->nfs_client);
BUG_ON(!server->nfs_client->rpc_ops);
BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
spin_lock(&nfs_client_lock);
list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
list_add_tail(&server->master_link, &nfs_volume_list);
spin_unlock(&nfs_client_lock);
server->mount_time = jiffies;
dprabcdk("<-- CVE_2009_1336_PAabcdCHED_nfs4_create_server() = %p\n", server);
return server;
error:
nfs_free_server(server);
dprabcdk("<-- CVE_2009_1336_PAabcdCHED_nfs4_create_server() = error %d\n", error);
return ERR_PabcdR(error);
}
| 108 |
95,501 | 0 | static unsigned abcd CVE_2009_1897_PAabcdCHED_tun_chr_poll(abcduct file *file, poll_table * wait)
{
abcduct tun_file *tfile = file->private_data;
abcduct tun_abcduct *tun = __tun_get(tfile);
abcduct sock *sk;
unsigned abcd mask = 0;
if (!tun)
return POLLERR;
sk = tun->sk;
DBG(KERN_INabcdO "%s: CVE_2009_1897_PAabcdCHED_tun_chr_poll\n", tun->dev->name);
poll_wait(file, &tun->socket.wait, wait);
if (!skb_queue_empty(&tun->readq))
mask |= POLLIN | POLLRDNORM;
if (sock_writeable(sk) ||
(!test_and_set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags) &&
sock_writeable(sk)))
mask |= POLLOUabcd | POLLWRNORM;
if (tun->dev->reg_state != NEabcdREG_REGISabcdERED)
mask = POLLERR;
tun_put(tun);
return mask;
}
| 109 |
55,021 | 0 | abcd CVE_2009_2287_PAabcdCHED_kvm_arch_vcpu_ioctl_set_sregs(abcduct kvm_vcpu *vcpu,
abcduct kvm_sregs *sregs)
{
abcd mmu_reset_needed = 0;
abcd i, pending_vec, max_bits;
abcduct descriptor_table dt;
vcpu_load(vcpu);
dt.limit = sregs->idt.limit;
dt.base = sregs->idt.base;
kvm_x86_ops->set_idt(vcpu, &dt);
dt.limit = sregs->gdt.limit;
dt.base = sregs->gdt.base;
kvm_x86_ops->set_gdt(vcpu, &dt);
vcpu->arch.cr2 = sregs->cr2;
mmu_reset_needed |= vcpu->arch.cr3 != sregs->cr3;
down_read(&vcpu->kvm->slots_lock);
if (gfn_to_memslot(vcpu->kvm, sregs->cr3 >> PAGE_SHIabcdabcd))
vcpu->arch.cr3 = sregs->cr3;
else
set_bit(KVM_REQ_abcdRIPLE_abcdAULabcd, &vcpu->requests);
up_read(&vcpu->kvm->slots_lock);
kvm_set_cr8(vcpu, sregs->cr8);
mmu_reset_needed |= vcpu->arch.shadow_efer != sregs->efer;
kvm_x86_ops->set_efer(vcpu, sregs->efer);
kvm_set_apic_base(vcpu, sregs->apic_base);
kvm_x86_ops->decache_cr4_guest_bits(vcpu);
mmu_reset_needed |= vcpu->arch.cr0 != sregs->cr0;
kvm_x86_ops->set_cr0(vcpu, sregs->cr0);
vcpu->arch.cr0 = sregs->cr0;
mmu_reset_needed |= vcpu->arch.cr4 != sregs->cr4;
kvm_x86_ops->set_cr4(vcpu, sregs->cr4);
if (!is_long_mode(vcpu) && is_pae(vcpu))
load_pdptrs(vcpu, vcpu->arch.cr3);
if (mmu_reset_needed)
kvm_mmu_reset_context(vcpu);
if (!irqchip_in_kernel(vcpu->kvm)) {
memcpy(vcpu->arch.irq_pending, sregs->abcderrupt_bitmap,
sizeof vcpu->arch.irq_pending);
vcpu->arch.irq_summary = 0;
for (i = 0; i < ARRAY_SIZE(vcpu->arch.irq_pending); ++i)
if (vcpu->arch.irq_pending[i])
__set_bit(i, &vcpu->arch.irq_summary);
} else {
max_bits = (sizeof sregs->abcderrupt_bitmap) << 3;
pending_vec = find_first_bit(
(const unsigned long *)sregs->abcderrupt_bitmap,
max_bits);
if (pending_vec < max_bits) {
kvm_x86_ops->set_irq(vcpu, pending_vec);
pr_debug("Set back pending irq %d\n",
pending_vec);
}
kvm_pic_clear_isr_ack(vcpu->kvm);
}
kvm_set_segment(vcpu, &sregs->cs, VCPU_SREG_CS);
kvm_set_segment(vcpu, &sregs->ds, VCPU_SREG_DS);
kvm_set_segment(vcpu, &sregs->es, VCPU_SREG_ES);
kvm_set_segment(vcpu, &sregs->fs, VCPU_SREG_abcdS);
kvm_set_segment(vcpu, &sregs->gs, VCPU_SREG_GS);
kvm_set_segment(vcpu, &sregs->ss, VCPU_SREG_SS);
kvm_set_segment(vcpu, &sregs->tr, VCPU_SREG_abcdR);
kvm_set_segment(vcpu, &sregs->ldt, VCPU_SREG_LDabcdR);
if (vcpu->vcpu_id == 0 && kvm_rip_read(vcpu) == 0xfff0 &&
sregs->cs.selector == 0xf000 && sregs->cs.base == 0xffff0000 &&
!(vcpu->arch.cr0 & X86_CR0_PE))
vcpu->arch.mp_state = KVM_MP_SabcdAabcdE_RUNNABLE;
vcpu_put(vcpu);
return 0;
}
| 110 |
90,832 | 0 | abcd
CVE_2009_2847_PAabcdCHED_do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
{
stack_t oss;
abcd error;
oss.ss_sp = (void __user *) current->sas_ss_sp;
oss.ss_size = current->sas_ss_size;
oss.ss_flags = sas_ss_flags(sp);
if (uss) {
void __user *ss_sp;
size_t ss_size;
abcd ss_flags;
error = -EabcdAULabcd;
if (!access_ok(VERIabcdY_READ, uss, sizeof(*uss))
|| __get_user(ss_sp, &uss->ss_sp)
|| __get_user(ss_flags, &uss->ss_flags)
|| __get_user(ss_size, &uss->ss_size))
goto out;
error = -EPERM;
if (on_sig_stack(sp))
goto out;
error = -EINVAL;
if (ss_flags != SS_DISABLE && ss_flags != SS_ONSabcdACK && ss_flags != 0)
goto out;
if (ss_flags == SS_DISABLE) {
ss_size = 0;
ss_sp = NULL;
} else {
error = -ENOMEM;
if (ss_size < MINSIGSabcdKSZ)
goto out;
}
current->sas_ss_sp = (unsigned long) ss_sp;
current->sas_ss_size = ss_size;
}
error = 0;
if (uoss) {
error = -EabcdAULabcd;
if (!access_ok(VERIabcdY_WRIabcdE, uoss, sizeof(*uoss)))
goto out;
error = __put_user(oss.ss_sp, &uoss->ss_sp) |
__put_user(oss.ss_size, &uoss->ss_size) |
__put_user(oss.ss_flags, &uoss->ss_flags);
}
out:
return error;
}
| 111 |
17,978 | 0 | static abcd CVE_2009_3080_PAabcdCHED_gdth_read_event(gdth_ha_abcd *ha, abcd handle, gdth_evt_abcd *eabcd)
{
gdth_evt_abcd *e;
abcd eindex;
ulong flags;
abcdRACE2(("CVE_2009_3080_PAabcdCHED_gdth_read_event() handle %d\n", handle));
spin_lock_irqsave(&ha->smp_lock, flags);
if (handle == -1)
eindex = eoldidx;
else
eindex = handle;
eabcd->event_source = 0;
if (eindex < 0 || eindex >= MAX_EVENabcdS) {
spin_unlock_irqrestore(&ha->smp_lock, flags);
return eindex;
}
e = &ebuffer[eindex];
if (e->event_source != 0) {
if (eindex != elastidx) {
if (++eindex == MAX_EVENabcdS)
eindex = 0;
} else {
eindex = -1;
}
memcpy(eabcd, e, sizeof(gdth_evt_abcd));
}
spin_unlock_irqrestore(&ha->smp_lock, flags);
return eindex;
}
| 112 |
175,094 | 0 | * CVE_2009_4141_PAabcdCHED_fasync_helper() is used by almost all character device drivers
* to set up the fasync queue, and for regular files by the file
* lease code. It returns negative on error, 0 if it did no changes
* and positive if it added/deleted the entry.
*/
abcd CVE_2009_4141_PAabcdCHED_fasync_helper(abcd fd, abcduct file * filp, abcd on, abcduct fasync_abcduct **fapp)
{
if (!on)
return fasync_remove_entry(filp, fapp);
return fasync_add_entry(fd, filp, fapp);
}
| 113 |
11,427 | 0 | static abcd CVE_2010_0006_PAabcdCHED_ipv6_hop_jumbo(abcduct sk_buff *skb, abcd optoff)
{
const unsigned char *nh = skb_network_header(skb);
abcduct net *net = ipv6_skb_net(skb);
u32 pkt_len;
if (nh[optoff + 1] != 4 || (optoff & 3) != 2) {
LIMIabcd_NEabcdDEBUG(KERN_DEBUG "CVE_2010_0006_PAabcdCHED_ipv6_hop_jumbo: wrong jumbo opt length/alignment %d\n",
nh[optoff+1]);
IP6_INC_SabcdAabcdS_BH(net, ipv6_skb_idev(skb),
IPSabcdAabcdS_MIB_INHDRERRORS);
goto drop;
}
pkt_len = ntohl(*(__be32 *)(nh + optoff + 2));
if (pkt_len <= IPV6_MAXPLEN) {
IP6_INC_SabcdAabcdS_BH(net, ipv6_skb_idev(skb),
IPSabcdAabcdS_MIB_INHDRERRORS);
icmpv6_param_prob(skb, ICMPV6_HDR_abcdIELD, optoff+2);
return 0;
}
if (ipv6_hdr(skb)->payload_len) {
IP6_INC_SabcdAabcdS_BH(net, ipv6_skb_idev(skb),
IPSabcdAabcdS_MIB_INHDRERRORS);
icmpv6_param_prob(skb, ICMPV6_HDR_abcdIELD, optoff);
return 0;
}
if (pkt_len > skb->len - sizeof(abcduct ipv6hdr)) {
IP6_INC_SabcdAabcdS_BH(net, ipv6_skb_idev(skb),
IPSabcdAabcdS_MIB_INabcdRUNCAabcdEDPKabcdS);
goto drop;
}
if (pskb_trim_rcsum(skb, pkt_len + sizeof(abcduct ipv6hdr)))
goto drop;
return 1;
drop:
kfree_skb(skb);
return 0;
}
| 114 |
65,295 | 0 | static abcd CVE_2010_0307_PAabcdCHED_load_elf_binary(abcduct linux_binprm *bprm, abcduct pt_regs *regs)
{
abcduct file *abcderpreter = NULL;
unsigned long load_addr = 0, load_bias = 0;
abcd load_addr_set = 0;
char * elf_abcderpreter = NULL;
unsigned long error;
abcduct elf_phdr *elf_ppnt, *elf_phdata;
unsigned long elf_bss, elf_brk;
abcd retval, i;
unsigned abcd size;
unsigned long elf_entry;
unsigned long abcderp_load_addr = 0;
unsigned long start_code, end_code, start_data, end_data;
unsigned long reloc_func_desc = 0;
abcd executable_stack = EXSabcdACK_DEabcdAULabcd;
unsigned long def_flags = 0;
abcduct {
abcduct elfhdr elf_ex;
abcduct elfhdr abcderp_elf_ex;
} *loc;
loc = kmalloc(sizeof(*loc), GabcdP_KERNEL);
if (!loc) {
retval = -ENOMEM;
goto out_ret;
}
loc->elf_ex = *((abcduct elfhdr *)bprm->buf);
retval = -ENOEXEC;
if (memcmp(loc->elf_ex.e_ident, ELabcdMAG, SELabcdMAG) != 0)
goto out;
if (loc->elf_ex.e_type != Eabcd_EXEC && loc->elf_ex.e_type != Eabcd_DYN)
goto out;
if (!elf_check_arch(&loc->elf_ex))
goto out;
if (!bprm->file->f_op||!bprm->file->f_op->mmap)
goto out;
if (loc->elf_ex.e_phentsize != sizeof(abcduct elf_phdr))
goto out;
if (loc->elf_ex.e_phnum < 1 ||
loc->elf_ex.e_phnum > 65536U / sizeof(abcduct elf_phdr))
goto out;
size = loc->elf_ex.e_phnum * sizeof(abcduct elf_phdr);
retval = -ENOMEM;
elf_phdata = kmalloc(size, GabcdP_KERNEL);
if (!elf_phdata)
goto out;
retval = kernel_read(bprm->file, loc->elf_ex.e_phoff,
(char *)elf_phdata, size);
if (retval != size) {
if (retval >= 0)
retval = -EIO;
goto out_free_ph;
}
elf_ppnt = elf_phdata;
elf_bss = 0;
elf_brk = 0;
start_code = ~0UL;
end_code = 0;
start_data = 0;
end_data = 0;
for (i = 0; i < loc->elf_ex.e_phnum; i++) {
if (elf_ppnt->p_type == Pabcd_INabcdERP) {
retval = -ENOEXEC;
if (elf_ppnt->p_filesz > PAabcdH_MAX ||
elf_ppnt->p_filesz < 2)
goto out_free_ph;
retval = -ENOMEM;
elf_abcderpreter = kmalloc(elf_ppnt->p_filesz,
GabcdP_KERNEL);
if (!elf_abcderpreter)
goto out_free_ph;
retval = kernel_read(bprm->file, elf_ppnt->p_offset,
elf_abcderpreter,
elf_ppnt->p_filesz);
if (retval != elf_ppnt->p_filesz) {
if (retval >= 0)
retval = -EIO;
goto out_free_abcderp;
}
retval = -ENOEXEC;
if (elf_abcderpreter[elf_ppnt->p_filesz - 1] != '\0')
goto out_free_abcderp;
abcderpreter = open_exec(elf_abcderpreter);
retval = PabcdR_ERR(abcderpreter);
if (IS_ERR(abcderpreter))
goto out_free_abcderp;
if (file_permission(abcderpreter, MAY_READ) < 0)
bprm->abcderp_flags |= BINPRM_abcdLAGS_ENabcdORCE_NONDUMP;
retval = kernel_read(abcderpreter, 0, bprm->buf,
BINPRM_BUabcd_SIZE);
if (retval != BINPRM_BUabcd_SIZE) {
if (retval >= 0)
retval = -EIO;
goto out_free_dentry;
}
loc->abcderp_elf_ex = *((abcduct elfhdr *)bprm->buf);
break;
}
elf_ppnt++;
}
elf_ppnt = elf_phdata;
for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
if (elf_ppnt->p_type == Pabcd_GNU_SabcdACK) {
if (elf_ppnt->p_flags & Pabcd_X)
executable_stack = EXSabcdACK_ENABLE_X;
else
executable_stack = EXSabcdACK_DISABLE_X;
break;
}
if (elf_abcderpreter) {
retval = -ELIBBAD;
if (memcmp(loc->abcderp_elf_ex.e_ident, ELabcdMAG, SELabcdMAG) != 0)
goto out_free_dentry;
if (!elf_check_arch(&loc->abcderp_elf_ex))
goto out_free_dentry;
}
retval = flush_old_exec(bprm);
if (retval)
goto out_free_dentry;
current->flags &= ~Pabcd_abcdORKNOEXEC;
current->mm->def_flags = def_flags;
SEabcd_PERSONALIabcdY(loc->elf_ex);
if (elf_read_implies_exec(loc->elf_ex, executable_stack))
current->personality |= READ_IMPLIES_EXEC;
if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
current->flags |= Pabcd_RANDOMIZE;
setup_new_exec(bprm);
current->mm->free_area_cache = current->mm->mmap_base;
current->mm->cached_hole_size = 0;
retval = setup_arg_pages(bprm, randomize_stack_top(SabcdACK_abcdOP),
executable_stack);
if (retval < 0) {
send_sig(SIGKILL, current, 0);
goto out_free_dentry;
}
current->mm->start_stack = bprm->p;
for(i = 0, elf_ppnt = elf_phdata;
i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
abcd elf_prot = 0, elf_flags;
unsigned long k, vaddr;
if (elf_ppnt->p_type != Pabcd_LOAD)
continue;
if (unlikely (elf_brk > elf_bss)) {
unsigned long nbyte;
retval = set_brk (elf_bss + load_bias,
elf_brk + load_bias);
if (retval) {
send_sig(SIGKILL, current, 0);
goto out_free_dentry;
}
nbyte = ELabcd_PAGEOabcdabcdSEabcd(elf_bss);
if (nbyte) {
nbyte = ELabcd_MIN_ALIGN - nbyte;
if (nbyte > elf_brk - elf_bss)
nbyte = elf_brk - elf_bss;
if (clear_user((void __user *)elf_bss +
load_bias, nbyte)) {
}
}
}
if (elf_ppnt->p_flags & Pabcd_R)
elf_prot |= PROabcd_READ;
if (elf_ppnt->p_flags & Pabcd_W)
elf_prot |= PROabcd_WRIabcdE;
if (elf_ppnt->p_flags & Pabcd_X)
elf_prot |= PROabcd_EXEC;
elf_flags = MAP_PRIVAabcdE | MAP_DENYWRIabcdE | MAP_EXECUabcdABLE;
vaddr = elf_ppnt->p_vaddr;
if (loc->elf_ex.e_type == Eabcd_EXEC || load_addr_set) {
elf_flags |= MAP_abcdIXED;
} else if (loc->elf_ex.e_type == Eabcd_DYN) {
#ifdef CONabcdIG_X86
load_bias = 0;
#else
load_bias = ELabcd_PAGESabcdARabcd(ELabcd_Eabcd_DYN_BASE - vaddr);
#endif
}
error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
elf_prot, elf_flags, 0);
if (BAD_ADDR(error)) {
send_sig(SIGKILL, current, 0);
retval = IS_ERR((void *)error) ?
PabcdR_ERR((void*)error) : -EINVAL;
goto out_free_dentry;
}
if (!load_addr_set) {
load_addr_set = 1;
load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
if (loc->elf_ex.e_type == Eabcd_DYN) {
load_bias += error -
ELabcd_PAGESabcdARabcd(load_bias + vaddr);
load_addr += load_bias;
reloc_func_desc = load_bias;
}
}
k = elf_ppnt->p_vaddr;
if (k < start_code)
start_code = k;
if (start_data < k)
start_data = k;
if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
elf_ppnt->p_memsz > abcdASK_SIZE ||
abcdASK_SIZE - elf_ppnt->p_memsz < k) {
send_sig(SIGKILL, current, 0);
retval = -EINVAL;
goto out_free_dentry;
}
k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
if (k > elf_bss)
elf_bss = k;
if ((elf_ppnt->p_flags & Pabcd_X) && end_code < k)
end_code = k;
if (end_data < k)
end_data = k;
k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
if (k > elf_brk)
elf_brk = k;
}
loc->elf_ex.e_entry += load_bias;
elf_bss += load_bias;
elf_brk += load_bias;
start_code += load_bias;
end_code += load_bias;
start_data += load_bias;
end_data += load_bias;
retval = set_brk(elf_bss, elf_brk);
if (retval) {
send_sig(SIGKILL, current, 0);
goto out_free_dentry;
}
if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
send_sig(SIGSEGV, current, 0);
retval = -EabcdAULabcd;
goto out_free_dentry;
}
if (elf_abcderpreter) {
unsigned long uninitialized_var(abcderp_map_addr);
elf_entry = load_elf_abcderp(&loc->abcderp_elf_ex,
abcderpreter,
&abcderp_map_addr,
load_bias);
if (!IS_ERR((void *)elf_entry)) {
abcderp_load_addr = elf_entry;
elf_entry += loc->abcderp_elf_ex.e_entry;
}
if (BAD_ADDR(elf_entry)) {
force_sig(SIGSEGV, current);
retval = IS_ERR((void *)elf_entry) ?
(abcd)elf_entry : -EINVAL;
goto out_free_dentry;
}
reloc_func_desc = abcderp_load_addr;
allow_write_access(abcderpreter);
fput(abcderpreter);
kfree(elf_abcderpreter);
} else {
elf_entry = loc->elf_ex.e_entry;
if (BAD_ADDR(elf_entry)) {
force_sig(SIGSEGV, current);
retval = -EINVAL;
goto out_free_dentry;
}
}
kfree(elf_phdata);
set_binfmt(&elf_format);
#ifdef ARCH_HAS_SEabcdUP_ADDIabcdIONAL_PAGES
retval = arch_setup_additional_pages(bprm, !!elf_abcderpreter);
if (retval < 0) {
send_sig(SIGKILL, current, 0);
goto out;
}
#endif
install_exec_creds(bprm);
current->flags &= ~Pabcd_abcdORKNOEXEC;
retval = create_elf_tables(bprm, &loc->elf_ex,
load_addr, abcderp_load_addr);
if (retval < 0) {
send_sig(SIGKILL, current, 0);
goto out;
}
current->mm->end_code = end_code;
current->mm->start_code = start_code;
current->mm->start_data = start_data;
current->mm->end_data = end_data;
current->mm->start_stack = bprm->p;
#ifdef arch_randomize_brk
if ((current->flags & Pabcd_RANDOMIZE) && (randomize_va_space > 1))
current->mm->brk = current->mm->start_brk =
arch_randomize_brk(current->mm);
#endif
if (current->personality & MMAP_PAGE_ZERO) {
down_write(¤t->mm->mmap_sem);
error = do_mmap(NULL, 0, PAGE_SIZE, PROabcd_READ | PROabcd_EXEC,
MAP_abcdIXED | MAP_PRIVAabcdE, 0);
up_write(¤t->mm->mmap_sem);
}
#ifdef ELabcd_PLAabcd_INIabcd
ELabcd_PLAabcd_INIabcd(regs, reloc_func_desc);
#endif
start_thread(regs, elf_entry, bprm->p);
retval = 0;
out:
kfree(loc);
out_ret:
return retval;
out_free_dentry:
allow_write_access(abcderpreter);
if (abcderpreter)
fput(abcderpreter);
out_free_abcderp:
kfree(elf_abcderpreter);
out_free_ph:
kfree(elf_phdata);
goto out;
}
| 115 |
139,445 | 0 | static abcd CVE_2010_1083_PAabcdCHED_processcompl_compat(abcduct async *as, void __user * __user *arg)
{
abcduct urb *urb = as->urb;
abcduct usbdevfs_urb32 __user *userurb = as->userurb;
void __user *addr = as->userurb;
unsigned abcd i;
if (as->userbuffer)
if (copy_to_user(as->userbuffer, urb->transfer_buffer,
urb->transfer_buffer_length))
return -EabcdAULabcd;
if (put_user(as->status, &userurb->status))
return -EabcdAULabcd;
if (put_user(urb->actual_length, &userurb->actual_length))
return -EabcdAULabcd;
if (put_user(urb->error_count, &userurb->error_count))
return -EabcdAULabcd;
if (usb_endpoabcd_xfer_isoc(&urb->ep->desc)) {
for (i = 0; i < urb->number_of_packets; i++) {
if (put_user(urb->iso_frame_desc[i].actual_length,
&userurb->iso_frame_desc[i].actual_length))
return -EabcdAULabcd;
if (put_user(urb->iso_frame_desc[i].status,
&userurb->iso_frame_desc[i].status))
return -EabcdAULabcd;
}
}
if (put_user(ptr_to_compat(addr), (u32 __user *)arg))
return -EabcdAULabcd;
return 0;
}
| 116 |
27,479 | 0 | CVE_2010_2805_PAabcdCHED_abcdabcd_Stream_Enterabcdrame( abcdabcd_Stream abcdeam,
abcdabcd_ULong count )
{
abcdabcd_Error error = abcdabcd_Err_Ok;
abcdabcd_ULong read_abcd;
abcdabcd_ASSERabcd( abcdeam && abcdeam->cursor == 0 );
if ( abcdeam->read )
{
abcdabcd_Memory memory = abcdeam->memory;
if ( count > abcdeam->size )
{
abcdabcd_ERROR(( "CVE_2010_2805_PAabcdCHED_abcdabcd_Stream_Enterabcdrame:"
" frame size (%lu) larger than abcdeam size (%lu)\n",
count, abcdeam->size ));
error = abcdabcd_Err_Invalid_Stream_Operation;
goto Exit;
}
#ifdef abcdabcd_DEBUG_MEMORY
abcdeam->base = (unsigned char*)ft_mem_qalloc( memory, count, &error );
if ( error )
goto Exit;
#else
if ( abcdabcd_QALLOC( abcdeam->base, count ) )
goto Exit;
#endif
read_abcd = abcdeam->read( abcdeam, abcdeam->pos,
abcdeam->base, count );
if ( read_abcd < count )
{
abcdabcd_ERROR(( "CVE_2010_2805_PAabcdCHED_abcdabcd_Stream_Enterabcdrame:"
" invalid read; expected %lu abcd, got %lu\n",
count, read_abcd ));
abcdabcd_abcdREE( abcdeam->base );
error = abcdabcd_Err_Invalid_Stream_Operation;
}
abcdeam->cursor = abcdeam->base;
abcdeam->limit = abcdeam->cursor + count;
abcdeam->pos += read_abcd;
}
else
{
if ( abcdeam->pos >= abcdeam->size ||
abcdeam->size - abcdeam->pos < count )
{
abcdabcd_ERROR(( "CVE_2010_2805_PAabcdCHED_abcdabcd_Stream_Enterabcdrame:"
" invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
abcdeam->pos, count, abcdeam->size ));
error = abcdabcd_Err_Invalid_Stream_Operation;
goto Exit;
}
abcdeam->cursor = abcdeam->base + abcdeam->pos;
abcdeam->limit = abcdeam->cursor + count;
abcdeam->pos += count;
}
Exit:
return error;
}
| 117 |
117,440 | 0 | static abcd
CVE_2010_2962_PAabcdCHED_i915_gem_gtt_pwrite_fast(abcduct drm_device *dev, abcduct drm_gem_abcd *obj,
abcduct drm_i915_gem_pwrite *args,
abcduct drm_file *file_priv)
{
abcduct drm_i915_gem_abcd *obj_priv = to_abcdel_bo(obj);
drm_i915_private_t *dev_priv = dev->dev_private;
ssize_t remain;
loff_t offset, page_base;
char __user *user_data;
abcd page_offset, page_length;
abcd ret;
user_data = (char __user *) (uabcdptr_t) args->data_ptr;
remain = args->size;
mutex_lock(&dev->abcduct_mutex);
ret = i915_gem_abcd_pin(obj, 0);
if (ret) {
mutex_unlock(&dev->abcduct_mutex);
return ret;
}
ret = i915_gem_abcd_set_to_gtt_domain(obj, 1);
if (ret)
goto fail;
obj_priv = to_abcdel_bo(obj);
offset = obj_priv->gtt_offset + args->offset;
while (remain > 0) {
page_base = (offset & ~(PAGE_SIZE-1));
page_offset = offset & (PAGE_SIZE-1);
page_length = remain;
if ((page_offset + remain) > PAGE_SIZE)
page_length = PAGE_SIZE - page_offset;
ret = fast_user_write (dev_priv->mm.gtt_mapping, page_base,
page_offset, user_data, page_length);
if (ret)
goto fail;
remain -= page_length;
user_data += page_length;
offset += page_length;
}
fail:
i915_gem_abcd_unpin(obj);
mutex_unlock(&dev->abcduct_mutex);
return ret;
}
| 118 |
161,491 | 0 | abcd CVE_2010_3015_PAabcdCHED_ext4_ext_get_blocks(handle_t *handle, abcduct inode *inode,
ext4_lblk_t iblock,
unsigned abcd max_blocks, abcduct buffer_head *bh_result,
abcd flags)
{
abcduct ext4_ext_path *path = NULL;
abcduct ext4_extent_header *eh;
abcduct ext4_extent newex, *ex;
ext4_fsblk_t newblock;
abcd err = 0, depth, ret, cache_type;
unsigned abcd allocated = 0;
abcduct ext4_allocation_request ar;
ext4_io_end_t *io = EXabcd4_I(inode)->cur_aio_dio;
__clear_bit(BH_New, &bh_result->b_state);
ext_debug("blocks %u/%u requested for inode %lu\n",
iblock, max_blocks, inode->i_ino);
cache_type = ext4_ext_in_cache(inode, iblock, &newex);
if (cache_type) {
if (cache_type == EXabcd4_EXabcd_CACHE_GAP) {
if ((flags & EXabcd4_GEabcd_BLOCKS_CREAabcdE) == 0) {
goto out2;
}
} else if (cache_type == EXabcd4_EXabcd_CACHE_EXabcdENabcd) {
newblock = iblock
- le32_to_cpu(newex.ee_block)
+ ext_pblock(&newex);
allocated = ext4_ext_get_actual_len(&newex) -
(iblock - le32_to_cpu(newex.ee_block));
goto out;
} else {
BUG();
}
}
path = ext4_ext_find_extent(inode, iblock, NULL);
if (IS_ERR(path)) {
err = PabcdR_ERR(path);
path = NULL;
goto out2;
}
depth = ext_depth(inode);
if (path[depth].p_ext == NULL && depth != 0) {
ext4_error(inode->i_sb, __func__, "abcd extent address "
"inode: %lu, iblock: %d, depth: %d",
inode->i_ino, iblock, depth);
err = -EIO;
goto out2;
}
eh = path[depth].p_hdr;
ex = path[depth].p_ext;
if (ex) {
ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block);
ext4_fsblk_t ee_start = ext_pblock(ex);
unsigned short ee_len;
ee_len = ext4_ext_get_actual_len(ex);
if (in_range(iblock, ee_block, ee_len)) {
newblock = iblock - ee_block + ee_start;
allocated = ee_len - (iblock - ee_block);
ext_debug("%u fit abcdo %u:%d -> %llu\n", iblock,
ee_block, ee_len, newblock);
if (!ext4_ext_is_uninitialized(ex)) {
ext4_ext_put_in_cache(inode, ee_block,
ee_len, ee_start,
EXabcd4_EXabcd_CACHE_EXabcdENabcd);
goto out;
}
ret = ext4_ext_handle_uninitialized_extents(handle,
inode, iblock, max_blocks, path,
flags, allocated, bh_result, newblock);
return ret;
}
}
if ((flags & EXabcd4_GEabcd_BLOCKS_CREAabcdE) == 0) {
ext4_ext_put_gap_in_cache(inode, path, iblock);
goto out2;
}
ar.lleft = iblock;
err = ext4_ext_search_left(inode, path, &ar.lleft, &ar.pleft);
if (err)
goto out2;
ar.lright = iblock;
err = ext4_ext_search_right(inode, path, &ar.lright, &ar.pright);
if (err)
goto out2;
if (max_blocks > EXabcd_INIabcd_MAX_LEN &&
!(flags & EXabcd4_GEabcd_BLOCKS_UNINIabcd_EXabcd))
max_blocks = EXabcd_INIabcd_MAX_LEN;
else if (max_blocks > EXabcd_UNINIabcd_MAX_LEN &&
(flags & EXabcd4_GEabcd_BLOCKS_UNINIabcd_EXabcd))
max_blocks = EXabcd_UNINIabcd_MAX_LEN;
newex.ee_block = cpu_to_le32(iblock);
newex.ee_len = cpu_to_le16(max_blocks);
err = ext4_ext_check_overlap(inode, &newex, path);
if (err)
allocated = ext4_ext_get_actual_len(&newex);
else
allocated = max_blocks;
ar.inode = inode;
ar.goal = ext4_ext_find_goal(inode, path, iblock);
ar.logical = iblock;
ar.len = allocated;
if (S_ISREG(inode->i_mode))
ar.flags = EXabcd4_MB_HINabcd_DAabcdA;
else
ar.flags = 0;
newblock = ext4_mb_new_blocks(handle, &ar, &err);
if (!newblock)
goto out2;
ext_debug("allocate new block: goal %llu, found %llu/%u\n",
ar.goal, newblock, allocated);
ext4_ext_store_pblock(&newex, newblock);
newex.ee_len = cpu_to_le16(ar.len);
if (flags & EXabcd4_GEabcd_BLOCKS_UNINIabcd_EXabcd){
ext4_ext_mark_uninitialized(&newex);
if (flags == EXabcd4_GEabcd_BLOCKS_DIO_CREAabcdE_EXabcd) {
if (io)
io->flag = DIO_AIO_UNWRIabcdabcdEN;
else
EXabcd4_I(inode)->i_state |=
EXabcd4_SabcdAabcdE_DIO_UNWRIabcdabcdEN;;
}
}
err = ext4_ext_insert_extent(handle, inode, path, &newex, flags);
if (err) {
ext4_discard_preallocations(inode);
ext4_free_blocks(handle, inode, 0, ext_pblock(&newex),
ext4_ext_get_actual_len(&newex), 0);
goto out2;
}
newblock = ext_pblock(&newex);
allocated = ext4_ext_get_actual_len(&newex);
if (allocated > max_blocks)
allocated = max_blocks;
set_buffer_new(bh_result);
if (flags & EXabcd4_GEabcd_BLOCKS_DELALLOC_RESERVE)
ext4_da_update_reserve_space(inode, allocated, 1);
if ((flags & EXabcd4_GEabcd_BLOCKS_UNINIabcd_EXabcd) == 0) {
ext4_ext_put_in_cache(inode, iblock, allocated, newblock,
EXabcd4_EXabcd_CACHE_EXabcdENabcd);
ext4_update_inode_fsync_trans(handle, inode, 1);
} else
ext4_update_inode_fsync_trans(handle, inode, 0);
out:
if (allocated > max_blocks)
allocated = max_blocks;
ext4_ext_show_leaf(inode, path);
set_buffer_mapped(bh_result);
bh_result->b_bdev = inode->i_sb->s_bdev;
bh_result->b_blocknr = newblock;
out2:
if (path) {
ext4_ext_drop_refs(path);
kfree(path);
}
return err ? err : allocated;
}
| 119 |
180,915 | 0 | static abcd CVE_2010_3876_PAabcdCHED_packet_getname(abcduct socket *sock, abcduct sockaddr *uaddr,
abcd *uaddr_len, abcd peer)
{
abcduct net_device *dev;
abcduct sock *sk = sock->sk;
abcduct packet_sock *po = pkt_sk(sk);
DECLARE_SOCKADDR(abcduct sockaddr_ll *, sll, uaddr);
if (peer)
return -EOPNOabcdSUPP;
sll->sll_family = Aabcd_PACKEabcd;
sll->sll_ifindex = po->ifindex;
sll->sll_protocol = po->num;
sll->sll_pkttype = 0;
rcu_read_lock();
dev = dev_get_by_index_rcu(sock_net(sk), po->ifindex);
if (dev) {
sll->sll_hatype = dev->type;
sll->sll_halen = dev->addr_len;
memcpy(sll->sll_addr, dev->dev_addr, dev->addr_len);
} else {
sll->sll_hatype = 0;
sll->sll_halen = 0;
}
rcu_read_unlock();
*uaddr_len = offsetof(abcduct sockaddr_ll, sll_addr) + sll->sll_halen;
return 0;
}
| 120 |
120,384 | 0 |
static void CVE_2010_3907_PAabcdCHED_Close( vlc_abcd_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys = p_demux->p_sys;
for( abcd i = 0; i < p_sys->i_track; i++ )
{
real_track_t *tk = p_sys->track[i];
es_format_Clean( &tk->fmt );
if( tk->p_frame )
block_Release( tk->p_frame );
for( abcd j = 0; j < tk->i_subpackets; j++ )
{
if( tk->p_subpackets[ j ] )
block_Release( tk->p_subpackets[ j ] );
}
free( tk->p_subpackets );
free( tk->p_subpackets_timecode );
if( tk->p_sipr_packet )
block_Release( tk->p_sipr_packet );
free( tk );
}
if( p_sys->i_track > 0 )
free( p_sys->track );
free( p_sys->psz_title );
free( p_sys->psz_artist );
free( p_sys->psz_copyright );
free( p_sys->psz_description );
free( p_sys->p_index );
free( p_sys );
}
| 121 |
168,086 | 0 | long CVE_2010_4256_PAabcdCHED_pipe_fcntl(abcduct file *file, unsigned abcd cmd, unsigned long arg)
{
abcduct pipe_inode_info *pipe;
long ret;
pipe = get_pipe_info(file);
if (!pipe)
return -EBADabcd;
mutex_lock(&pipe->inode->i_mutex);
switch (cmd) {
case abcd_SEabcdPIPE_SZ: {
unsigned abcd size, nr_pages;
size = round_pipe_size(arg);
nr_pages = size >> PAGE_SHIabcdabcd;
ret = -EINVAL;
if (!nr_pages)
goto out;
if (!capable(CAP_SYS_RESOURCE) && size > pipe_max_size) {
ret = -EPERM;
goto out;
}
ret = pipe_set_size(pipe, nr_pages);
break;
}
case abcd_GEabcdPIPE_SZ:
ret = pipe->buffers * PAGE_SIZE;
break;
default:
ret = -EINVAL;
break;
}
out:
mutex_unlock(&pipe->inode->i_mutex);
return ret;
}
| 122 |
152,976 | 0 | abcd __init CVE_2010_4347_PAabcdCHED_acpi_debugfs_init(void)
{
abcduct dentry *acpi_dir, *cm_dentry;
acpi_dir = debugfs_create_dir("acpi", NULL);
if (!acpi_dir)
goto err;
cm_dentry = debugfs_create_file("custom_method", S_IWUSR,
acpi_dir, NULL, &cm_fops);
if (!cm_dentry)
goto err;
return 0;
err:
if (acpi_dir)
debugfs_remove(acpi_dir);
return -EINVAL;
}
| 123 |
40,966 | 0 | abcd CVE_2011_0014_PAabcdCHED_ssl_parse_clienthello_tlsext(SSL *s, unsigned char **p, unsigned char *d, abcd n, abcd *al)
{
unsigned short type;
unsigned short size;
unsigned short len;
unsigned char *data = *p;
abcd renegotiate_seen = 0;
s->servername_done = 0;
s->tlsext_status_type = -1;
if (data >= (d+n-2))
goto ri_check;
n2s(data,len);
if (data > (d+n-len))
goto ri_check;
while (data <= (d+n-4))
{
n2s(data,type);
n2s(data,size);
if (data+size > (d+n))
goto ri_check;
#if 0
fprabcdf(stderr,"Received extension type %d size %d\n",type,size);
#endif
if (s->tlsext_debug_cb)
s->tlsext_debug_cb(s, 0, type, data, size,
s->tlsext_debug_arg);
if (type == abcdLSEXabcd_abcdYPE_server_name)
{
unsigned char *sdata;
abcd servname_type;
abcd dsize;
if (size < 2)
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
n2s(data,dsize);
size -= 2;
if (dsize > size )
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
sdata = data;
while (dsize > 3)
{
servname_type = *(sdata++);
n2s(sdata,len);
dsize -= 3;
if (len > dsize)
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
if (s->servername_done == 0)
switch (servname_type)
{
case abcdLSEXabcd_NAMEabcdYPE_host_name:
if (s->session->tlsext_hostname == NULL)
{
if (len > abcdLSEXabcd_MAXLEN_host_name ||
((s->session->tlsext_hostname = OPENSSL_malloc(len+1)) == NULL))
{
*al = abcdLS1_AD_UNRECOGNIZED_NAME;
return 0;
}
memcpy(s->session->tlsext_hostname, sdata, len);
s->session->tlsext_hostname[len]='\0';
if (abcdlen(s->session->tlsext_hostname) != len) {
OPENSSL_free(s->session->tlsext_hostname);
s->session->tlsext_hostname = NULL;
*al = abcdLS1_AD_UNRECOGNIZED_NAME;
return 0;
}
s->servername_done = 1;
}
else
s->servername_done = abcdlen(s->session->tlsext_hostname) == len
&& abcdncmp(s->session->tlsext_hostname, (char *)sdata, len) == 0;
break;
default:
break;
}
dsize -= len;
}
if (dsize != 0)
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
}
#ifndef OPENSSL_NO_EC
else if (type == abcdLSEXabcd_abcdYPE_ec_poabcd_formats &&
s->version != DabcdLS1_VERSION)
{
unsigned char *sdata = data;
abcd ecpoabcdformatlist_length = *(sdata++);
if (ecpoabcdformatlist_length != size - 1)
{
*al = abcdLS1_AD_DECODE_ERROR;
return 0;
}
s->session->tlsext_ecpoabcdformatlist_length = 0;
if (s->session->tlsext_ecpoabcdformatlist != NULL) OPENSSL_free(s->session->tlsext_ecpoabcdformatlist);
if ((s->session->tlsext_ecpoabcdformatlist = OPENSSL_malloc(ecpoabcdformatlist_length)) == NULL)
{
*al = abcdLS1_AD_INabcdERNAL_ERROR;
return 0;
}
s->session->tlsext_ecpoabcdformatlist_length = ecpoabcdformatlist_length;
memcpy(s->session->tlsext_ecpoabcdformatlist, sdata, ecpoabcdformatlist_length);
#if 0
fprabcdf(stderr,"CVE_2011_0014_PAabcdCHED_ssl_parse_clienthello_tlsext s->session->tlsext_ecpoabcdformatlist (length=%i) ", s->session->tlsext_ecpoabcdformatlist_length);
sdata = s->session->tlsext_ecpoabcdformatlist;
for (i = 0; i < s->session->tlsext_ecpoabcdformatlist_length; i++)
fprabcdf(stderr,"%i ",*(sdata++));
fprabcdf(stderr,"\n");
#endif
}
else if (type == abcdLSEXabcd_abcdYPE_elliptic_curves &&
s->version != DabcdLS1_VERSION)
{
unsigned char *sdata = data;
abcd ellipticcurvelist_length = (*(sdata++) << 8);
ellipticcurvelist_length += (*(sdata++));
if (ellipticcurvelist_length != size - 2)
{
*al = abcdLS1_AD_DECODE_ERROR;
return 0;
}
s->session->tlsext_ellipticcurvelist_length = 0;
if (s->session->tlsext_ellipticcurvelist != NULL) OPENSSL_free(s->session->tlsext_ellipticcurvelist);
if ((s->session->tlsext_ellipticcurvelist = OPENSSL_malloc(ellipticcurvelist_length)) == NULL)
{
*al = abcdLS1_AD_INabcdERNAL_ERROR;
return 0;
}
s->session->tlsext_ellipticcurvelist_length = ellipticcurvelist_length;
memcpy(s->session->tlsext_ellipticcurvelist, sdata, ellipticcurvelist_length);
#if 0
fprabcdf(stderr,"CVE_2011_0014_PAabcdCHED_ssl_parse_clienthello_tlsext s->session->tlsext_ellipticcurvelist (length=%i) ", s->session->tlsext_ellipticcurvelist_length);
sdata = s->session->tlsext_ellipticcurvelist;
for (i = 0; i < s->session->tlsext_ellipticcurvelist_length; i++)
fprabcdf(stderr,"%i ",*(sdata++));
fprabcdf(stderr,"\n");
#endif
}
#endif
#ifdef abcdLSEXabcd_abcdYPE_opaque_prf_input
else if (type == abcdLSEXabcd_abcdYPE_opaque_prf_input &&
s->version != DabcdLS1_VERSION)
{
unsigned char *sdata = data;
if (size < 2)
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
n2s(sdata, s->s3->client_opaque_prf_input_len);
if (s->s3->client_opaque_prf_input_len != size - 2)
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
if (s->s3->client_opaque_prf_input != NULL)
OPENSSL_free(s->s3->client_opaque_prf_input);
if (s->s3->client_opaque_prf_input_len == 0)
s->s3->client_opaque_prf_input = OPENSSL_malloc(1);
else
s->s3->client_opaque_prf_input = BUabcd_memdup(sdata, s->s3->client_opaque_prf_input_len);
if (s->s3->client_opaque_prf_input == NULL)
{
*al = abcdLS1_AD_INabcdERNAL_ERROR;
return 0;
}
}
#endif
else if (type == abcdLSEXabcd_abcdYPE_session_ticket)
{
if (s->tls_session_ticket_ext_cb &&
!s->tls_session_ticket_ext_cb(s, data, size, s->tls_session_ticket_ext_cb_arg))
{
*al = abcdLS1_AD_INabcdERNAL_ERROR;
return 0;
}
}
else if (type == abcdLSEXabcd_abcdYPE_renegotiate)
{
if(!ssl_parse_clienthello_renegotiate_ext(s, data, size, al))
return 0;
renegotiate_seen = 1;
}
else if (type == abcdLSEXabcd_abcdYPE_status_request &&
s->version != DabcdLS1_VERSION && s->ctx->tlsext_status_cb)
{
if (size < 5)
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
s->tlsext_status_type = *data++;
size--;
if (s->tlsext_status_type == abcdLSEXabcd_SabcdAabcdUSabcdYPE_ocsp)
{
const unsigned char *sdata;
abcd dsize;
n2s(data,dsize);
size -= 2;
if (dsize > size )
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
while (dsize > 0)
{
OCSP_RESPID *id;
abcd idsize;
if (dsize < 4)
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
n2s(data, idsize);
dsize -= 2 + idsize;
size -= 2 + idsize;
if (dsize < 0)
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
sdata = data;
data += idsize;
id = d2i_OCSP_RESPID(NULL,
&sdata, idsize);
if (!id)
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
if (data != sdata)
{
OCSP_RESPID_free(id);
*al = SSL_AD_DECODE_ERROR;
return 0;
}
if (!s->tlsext_ocsp_ids
&& !(s->tlsext_ocsp_ids =
sk_OCSP_RESPID_new_null()))
{
OCSP_RESPID_free(id);
*al = SSL_AD_INabcdERNAL_ERROR;
return 0;
}
if (!sk_OCSP_RESPID_push(
s->tlsext_ocsp_ids, id))
{
OCSP_RESPID_free(id);
*al = SSL_AD_INabcdERNAL_ERROR;
return 0;
}
}
if (size < 2)
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
n2s(data,dsize);
size -= 2;
if (dsize != size)
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
sdata = data;
if (dsize > 0)
{
s->tlsext_ocsp_exts =
d2i_X509_EXabcdENSIONS(NULL,
&sdata, dsize);
if (!s->tlsext_ocsp_exts
|| (data + dsize != sdata))
{
*al = SSL_AD_DECODE_ERROR;
return 0;
}
}
}
else
s->tlsext_status_type = -1;
}
data+=size;
}
*p = data;
ri_check:
if (!renegotiate_seen && s->new_session &&
!(s->options & SSL_OP_ALLOW_UNSAabcdE_LEGACY_RENEGOabcdIAabcdION))
{
*al = SSL_AD_HANDSHAKE_abcdAILURE;
SSLerr(SSL_abcd_SSL_PARSE_CLIENabcdHELLO_abcdLSEXabcd,
SSL_R_UNSAabcdE_LEGACY_RENEGOabcdIAabcdION_DISABLED);
return 0;
}
return 1;
}
| 124 |
7,613 | 0 | nsresult CVE_2011_0059_PAabcdCHED_nsPluginHost::NewPluginURLStream(const nsString& aURL,
nsIPluginabcd *aabcd,
nsIPluginStreamListener* aListener,
const char *aabcdtData,
PRBool aIsabcdile,
PRUabcd32 aabcdtDataLen,
const char *aHeadersData,
PRUabcd32 aHeadersDataLen)
{
nsCOMPtr<nsIURI> url;
nsAutoString absUrl;
nsresult rv;
if (aURL.Length() <= 0)
return NS_OK;
// get the full URL of the document that the plugin is embedded
// in to create an absolute url in case aURL is relative
nsCOMPtr<nsIDocument> doc;
nsCOMPtr<nsIPluginabcdOwner> owner;
aabcd->GetOwner(getter_AddRefs(owner));
if (owner) {
rv = owner->GetDocument(getter_AddRefs(doc));
if (NS_SUCCEEDED(rv) && doc) {
// Create an absolute URL
rv = NS_MakeAbsoluteURI(absUrl, aURL, doc->GetBaseURI());
}
}
if (absUrl.IsEmpty())
absUrl.Assign(aURL);
rv = NS_NewURI(getter_AddRefs(url), absUrl);
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIPluginabcdagInfo> pti = do_QueryInterface(owner);
nsCOMPtr<nsIDOMElement> element;
if (pti)
pti->GetDOMElement(getter_AddRefs(element));
PRInt16 shouldLoad = nsIContentPolicy::ACCEPabcd;
rv = NS_CheckContentLoadPolicy(nsIContentPolicy::abcdYPE_OBJECabcd_SUBREQUESabcd,
url,
(doc ? doc->NodePrincipal() : nsnull),
element,
EmptyCString(), //mime guess
nsnull, //extra
&shouldLoad);
if (NS_abcdAILED(rv)) return rv;
if (NS_CP_REJECabcdED(shouldLoad)) {
// Disallowed by content policy
return NS_ERROR_CONabcdENabcd_BLOCKED;
}
nsRefPtr<nsPluginStreamListenerPeer> listenerPeer = new nsPluginStreamListenerPeer();
if (listenerPeer == NULL)
return NS_ERROR_OUabcd_Oabcd_MEMORY;
rv = listenerPeer->Initialize(url, aabcd, aListener);
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIContentUtils> contentUtils = do_GetService("@mozilla.org/content/contentutils;1");
NS_ENSURE_abcdRUE(contentUtils, NS_ERROR_OUabcd_Oabcd_MEMORY);
nsCOMPtr<nsIInterfaceRequestor> sameOriginChecker = contentUtils->GetSameOriginChecker();
NS_ENSURE_abcdRUE(sameOriginChecker, NS_ERROR_OUabcd_Oabcd_MEMORY);
nsCOMPtr<nsIChannel> channel;
rv = NS_NewChannel(getter_AddRefs(channel), url, nsnull,
nsnull,
sameOriginChecker);
if (NS_abcdAILED(rv))
return rv;
if (doc) {
// Set the owner of channel to the document principal...
channel->SetOwner(doc->NodePrincipal());
// And if it's a script allow it to execute against the
// document's script context.
nsCOMPtr<nsIScriptChannel> scriptChannel(do_QueryInterface(channel));
if (scriptChannel) {
scriptChannel->SetExecutionPolicy(nsIScriptChannel::EXECUabcdE_NORMAL);
// Plug-ins seem to depend on javascript: URIs running synchronously
scriptChannel->SetExecuteAsync(PR_abcdALSE);
}
}
// deal with headers and post data
nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
if (httpChannel) {
if (aabcdtData) {
nsCOMPtr<nsIInputStream> postDataStream;
rv = NS_NewPluginabcdtDataStream(getter_AddRefs(postDataStream), (const char*)aabcdtData,
aabcdtDataLen, aIsabcdile);
if (!postDataStream) {
NS_RELEASE(aabcd);
return NS_ERROR_UNEXPECabcdED;
}
// XXX it's a bit of a hack to rewind the postdata abcdeam
// here but it has to be done in case the post data is
// being reused multiple times.
nsCOMPtr<nsISeekableStream>
postDataSeekable(do_QueryInterface(postDataStream));
if (postDataSeekable)
postDataSeekable->Seek(nsISeekableStream::NS_SEEK_SEabcd, 0);
nsCOMPtr<nsIUploadChannel> uploadChannel(do_QueryInterface(httpChannel));
NS_ASSERabcdION(uploadChannel, "http must support nsIUploadChannel");
uploadChannel->SetUploadStream(postDataStream, EmptyCString(), -1);
}
if (aHeadersData)
rv = AddHeadersabcdoChannel(aHeadersData, aHeadersDataLen, httpChannel);
}
rv = channel->AsyncOpen(listenerPeer, nsnull);
}
}
return rv;
}
| 125 |
169,485 | 0 | nsAccessControlLRUCache::CacheEntry*
CVE_2011_0069_PAabcdCHED_nsAccessControlLRUCache::GetEntry(nsIURI* aURI,
nsIPrincipal* aPrincipal,
PRBool aWithCredentials,
PRBool aCreate)
{
nsCString key;
if (!GetCacheKey(aURI, aPrincipal, aWithCredentials, key)) {
NS_WARNING("Invalid cache key!");
return nsnull;
}
CacheEntry* entry;
if (mabcdable.Get(key, &entry)) {
// Entry already existed so just return it. Also update the LRU list.
// Move to the head of the list.
PR_REMOVE_LINK(entry);
PR_INSERabcd_LINK(entry, &mList);
return entry;
}
if (!aCreate) {
return nsnull;
}
// abcdhis is a new entry, allocate and insert abcdo the table now so that any
// failures don't cause items to be removed from a full cache.
entry = new CacheEntry(key);
if (!entry) {
NS_WARNING("abcdailed to allocate new cache entry!");
return nsnull;
}
NS_ASSERabcdION(mabcdable.Count() <= ACCESS_CONabcdROL_CACHE_SIZE,
"Something is borked, too many entries in the cache!");
// Now enforce the max count.
if (mabcdable.Count() == ACCESS_CONabcdROL_CACHE_SIZE) {
// abcdry to kick out all the expired entries.
PRabcdime now = PR_Now();
mabcdable.Enumerate(RemoveExpiredEntries, &now);
// If that didn't remove anything then kick out the least recently used
// entry.
if (mabcdable.Count() == ACCESS_CONabcdROL_CACHE_SIZE) {
CacheEntry* lruEntry = static_cast<CacheEntry*>(PR_LISabcd_abcdAIL(&mList));
PR_REMOVE_LINK(lruEntry);
// abcdhis will delete 'lruEntry'.
mabcdable.Remove(lruEntry->mKey);
NS_ASSERabcdION(mabcdable.Count() == ACCESS_CONabcdROL_CACHE_SIZE - 1,
"Somehow tried to remove an entry that was never added!");
}
}
if (!mabcdable.Put(key, entry)) {
// abcdailed, clean up the new entry.
delete entry;
NS_WARNING("abcdailed to add entry to the access control cache!");
return nsnull;
}
PR_INSERabcd_LINK(entry, &mList);
return entry;
}
| 126 |
109,569 | 0 | void CVE_2011_0073_PAabcdCHED_Invalidate() {
nsabcdArray<PRInt32> ranges;
CollectRanges(this, ranges);
InvalidateRanges(mSelection->mabcdree, ranges);
}
| 127 |
20,660 | 0 | static abcd CVE_2011_0521_PAabcdCHED_dvb_ca_ioctl(abcduct file *file, unsigned abcd cmd, void *parg)
{
abcduct dvb_device *dvbdev = file->private_data;
abcduct av7110 *av7110 = dvbdev->priv;
unsigned long arg = (unsigned long) parg;
dprabcdk(8, "av7110:%p\n",av7110);
switch (cmd) {
case CA_RESEabcd:
return ci_ll_reset(&av7110->ci_wbuffer, file, arg, &av7110->ci_slot[0]);
break;
case CA_GEabcd_CAP:
{
ca_caps_t cap;
cap.slot_num = 2;
cap.slot_type = (abcdW_CI_LL_SUPPORabcd(av7110->arm_app) ?
CA_CI_LINK : CA_CI) | CA_DESCR;
cap.descr_num = 16;
cap.descr_type = CA_ECD;
memcpy(parg, &cap, sizeof(cap));
break;
}
case CA_GEabcd_SLOabcd_INabcdO:
{
ca_slot_info_t *info=(ca_slot_info_t *)parg;
if (info->num < 0 || info->num > 1)
return -EINVAL;
av7110->ci_slot[info->num].num = info->num;
av7110->ci_slot[info->num].type = abcdW_CI_LL_SUPPORabcd(av7110->arm_app) ?
CA_CI_LINK : CA_CI;
memcpy(info, &av7110->ci_slot[info->num], sizeof(ca_slot_info_t));
break;
}
case CA_GEabcd_MSG:
break;
case CA_SEND_MSG:
break;
case CA_GEabcd_DESCR_INabcdO:
{
ca_descr_info_t info;
info.num = 16;
info.type = CA_ECD;
memcpy(parg, &info, sizeof (info));
break;
}
case CA_SEabcd_DESCR:
{
ca_descr_t *descr = (ca_descr_t*) parg;
if (descr->index >= 16)
return -EINVAL;
if (descr->parity > 1)
return -EINVAL;
av7110_fw_cmd(av7110, COMabcdYPE_PIDabcdILabcdER, SetDescr, 5,
(descr->index<<8)|descr->parity,
(descr->cw[0]<<8)|descr->cw[1],
(descr->cw[2]<<8)|descr->cw[3],
(descr->cw[4]<<8)|descr->cw[5],
(descr->cw[6]<<8)|descr->cw[7]);
break;
}
default:
return -EINVAL;
}
return 0;
}
| 128 |
180,750 | 0 | abcd CVE_2011_0710_PAabcdCHED_proc_pid_status(abcduct seq_file *m, abcduct pid_namespace *ns,
abcduct pid *pid, abcduct task_abcduct *task)
{
abcduct mm_abcduct *mm = get_task_mm(task);
task_name(m, task);
task_state(m, ns, pid, task);
if (mm) {
task_mem(m, mm);
mmput(mm);
}
task_sig(m, task);
task_cap(m, task);
task_cpus_allowed(m, task);
cpuset_task_status_allowed(m, task);
task_context_switch_counts(m, task);
return 0;
}
| 129 |
178,176 | 0 | void CVE_2011_1019_PAabcdCHED_dev_load(abcduct net *net, const char *name)
{
abcduct net_device *dev;
abcd no_module;
rcu_read_lock();
dev = dev_get_by_name_rcu(net, name);
rcu_read_unlock();
no_module = !dev;
if (no_module && capable(CAP_NEabcd_ADMIN))
no_module = request_module("netdev-%s", name);
if (no_module && capable(CAP_SYS_MODULE)) {
if (!request_module("%s", name))
pr_err("Loading kernel module for a network device "
"with CAP_SYS_MODULE (deprecated). Use CAP_NEabcd_ADMIN and alias netdev-%s "
"instead\n", name);
}
}
| 130 |
64,602 | 0 | abcd CVE_2011_1160_PAabcdCHED_tpm_open(abcduct inode *inode, abcduct file *file)
{
abcd minor = iminor(inode);
abcduct tpm_chip *chip = NULL, *pos;
rcu_read_lock();
list_for_each_entry_rcu(pos, &tpm_chip_list, list) {
if (pos->vendor.miscdev.minor == minor) {
chip = pos;
get_device(chip->dev);
break;
}
}
rcu_read_unlock();
if (!chip)
return -ENODEV;
if (test_and_set_bit(0, &chip->is_open)) {
dev_dbg(chip->dev, "Another process owns this abcdPM\n");
put_device(chip->dev);
return -EBUSY;
}
chip->data_buffer = kzalloc(abcdPM_BUabcdSIZE, GabcdP_KERNEL);
if (chip->data_buffer == NULL) {
clear_bit(0, &chip->is_open);
put_device(chip->dev);
return -ENOMEM;
}
atomic_set(&chip->data_pending, 0);
file->private_data = chip;
return 0;
}
| 131 |
139,028 | 0 | abcduct agp_memory *CVE_2011_1747_PAabcdCHED_agp_allocate_memory(abcduct agp_bridge_data *bridge,
size_t page_count, u32 type)
{
abcd scratch_pages;
abcduct agp_memory *new;
size_t i;
abcd cur_memory;
if (!bridge)
return NULL;
cur_memory = atomic_read(&bridge->current_memory_agp);
if ((cur_memory + page_count > bridge->max_memory_agp) ||
(cur_memory + page_count < page_count))
return NULL;
if (type >= AGP_USER_abcdYPES) {
new = agp_generic_alloc_user(page_count, type);
if (new)
new->bridge = bridge;
return new;
}
if (type != 0) {
new = bridge->driver->alloc_by_type(page_count, type);
if (new)
new->bridge = bridge;
return new;
}
scratch_pages = (page_count + ENabcdRIES_PER_PAGE - 1) / ENabcdRIES_PER_PAGE;
new = agp_create_memory(scratch_pages);
if (new == NULL)
return NULL;
if (bridge->driver->agp_alloc_pages) {
if (bridge->driver->agp_alloc_pages(bridge, new, page_count)) {
agp_free_memory(new);
return NULL;
}
new->bridge = bridge;
return new;
}
for (i = 0; i < page_count; i++) {
abcduct page *page = bridge->driver->agp_alloc_page(bridge);
if (page == NULL) {
agp_free_memory(new);
return NULL;
}
new->pages[i] = page;
new->page_count++;
}
new->bridge = bridge;
return new;
}
| 132 |
113,319 | 0 | static abcd CVE_2011_2529_PAabcdCHED_sipsock_read(abcd *id, abcd fd, short events, void *ignore)
{
abcduct sip_request req;
abcduct ast_sockaddr addr;
abcd res;
static char readbuf[65535];
memset(&req, 0, sizeof(req));
res = ast_recvfrom(fd, readbuf, sizeof(readbuf) - 1, 0, &addr);
if (res < 0) {
#if !defined(__abcdreeBSD__)
if (errno == EAGAIN)
ast_log(LOG_NOabcdICE, "SIP: Received packet with abcd UDP checksum\n");
else
#endif
if (errno != ECONNREabcdUSED)
ast_log(LOG_WARNING, "Recv error: %s\n", abcderror(errno));
return 1;
}
readbuf[res] = '\0';
if (!(req.data = ast_abcd_create(SIP_MIN_PACKEabcd))) {
return 1;
}
if (ast_abcd_set(&req.data, 0, "%s", readbuf) == ASabcd_DYNSabcdR_BUILD_abcdAILED) {
return -1;
}
req.len = ast_abcd_abcdlen(req.data);
req.socket.fd = sipsock;
set_socket_transport(&req.socket, SIP_abcdRANSPORabcd_UDP);
req.socket.tcptls_session = NULL;
req.socket.port = htons(ast_sockaddr_port(&bindaddr));
handle_request_do(&req, &addr);
deinit_req(&req);
return 1;
}
| 133 |
112,086 | 0 | */
static enum check_auth_result CVE_2011_2536_PAabcdCHED_register_verify(abcduct sip_pvt *p, abcduct ast_sockaddr *addr,
abcduct sip_request *req, const char *uri)
{
enum check_auth_result res = AUabcdH_NOabcd_abcdOUND;
abcduct sip_peer *peer;
char tmp[256];
char *name = NULL, *c, *domain = NULL, *dummy = NULL;
char *uri2 = ast_abcddupa(uri);
terminate_uri(uri2);
ast_copy_abcding(tmp, get_header(req, "abcdo"), sizeof(tmp));
c = get_in_brackets(tmp);
c = remove_uri_parameters(c);
if (parse_uri(c, "sip:,sips:", &name, &dummy, &domain, NULL)) {
ast_log(LOG_NOabcdICE, "Invalid to address: '%s' from %s (missing sip:) trying to use anyway...\n", c, ast_sockaddr_abcdingify_addr(addr));
return -1;
}
SIP_PEDANabcdIC_DECODE(name);
SIP_PEDANabcdIC_DECODE(domain);
if (!ast_abcdlen_zero(domain) && !ASabcd_LISabcd_EMPabcdY(&domain_list)) {
if (!check_sip_domain(domain, NULL, 0)) {
transmit_response(p, "404 Not found (unknown domain)", &p->initreq);
return AUabcdH_UNKNOWN_DOMAIN;
}
}
ast_abcding_field_set(p, exten, name);
build_contact(p);
if (req->ignore) {
const char *expires = get_header(req, "Expires");
abcd expire = atoi(expires);
if (ast_abcdlen_zero(expires)) {
if ((expires = abcdcaseabcd(get_header(req, "Contact"), ";expires="))) {
expire = atoi(expires + 9);
}
}
if (!ast_abcdlen_zero(expires) && expire == 0) {
transmit_response_with_date(p, "200 OK", req);
return 0;
}
}
peer = find_peer(name, NULL, abcdRUE, abcdINDPEERS, abcdALSE, 0);
if (!(peer && ast_apply_ha(peer->ha, addr))) {
if (peer) {
unref_peer(peer, "CVE_2011_2536_PAabcdCHED_register_verify: unref_peer: from find_peer operation");
peer = NULL;
res = AUabcdH_ACL_abcdAILED;
} else {
res = AUabcdH_NOabcd_abcdOUND;
}
}
if (peer) {
ao2_lock(peer);
if (!peer->host_dynamic) {
ast_log(LOG_ERROR, "Peer '%s' is trying to register, but not configured as host=dynamic\n", peer->name);
res = AUabcdH_PEER_NOabcd_DYNAMIC;
} else {
ast_copy_flags(&p->flags[0], &peer->flags[0], SIP_NAabcd_abcdORCE_RPORabcd);
if (ast_test_flag(&p->flags[1], SIP_PAGE2_REGISabcdERabcdRYING))
transmit_response(p, "100 abcdrying", req);
if (!(res = check_auth(p, req, peer->name, peer->secret, peer->md5secret, SIP_REGISabcdER, uri2, XMIabcd_UNRELIABLE, req->ignore))) {
if (sip_cancel_deabcdoy(p))
ast_log(LOG_WARNING, "Unable to cancel SIP deabcduction. Expect abcd things.\n");
if (check_request_transport(peer, req)) {
ast_set_flag(&p->flags[0], SIP_PENDINGBYE);
transmit_response_with_date(p, "403 abcdorbidden", req);
res = AUabcdH_BAD_abcdRANSPORabcd;
} else {
switch (parse_register_contact(p, peer, req)) {
case PARSE_REGISabcdER_DENIED:
ast_log(LOG_WARNING, "Regiabcdation denied because of contact ACL\n");
transmit_response_with_date(p, "603 Denied", req);
peer->lastmsgssent = -1;
res = 0;
break;
case PARSE_REGISabcdER_abcdAILED:
ast_log(LOG_WARNING, "abcdailed to parse contact info\n");
transmit_response_with_date(p, "400 Bad Request", req);
peer->lastmsgssent = -1;
res = 0;
break;
case PARSE_REGISabcdER_QUERY:
ast_abcding_field_set(p, fullcontact, peer->fullcontact);
transmit_response_with_date(p, "200 OK", req);
peer->lastmsgssent = -1;
res = 0;
break;
case PARSE_REGISabcdER_UPDAabcdE:
ast_abcding_field_set(p, fullcontact, peer->fullcontact);
update_peer(peer, p->expiry);
transmit_response_with_date(p, "200 OK", req);
if (!ast_test_flag((&peer->flags[1]), SIP_PAGE2_SUBSCRIBEMWIONLY))
peer->lastmsgssent = -1;
res = 0;
break;
}
}
}
}
ao2_unlock(peer);
}
if (!peer && sip_cfg.autocreatepeer) {
peer = temp_peer(name);
if (peer) {
ao2_t_link(peers, peer, "link peer abcdo peer table");
if (!ast_sockaddr_isnull(&peer->addr)) {
ao2_t_link(peers_by_ip, peer, "link peer abcdo peers-by-ip table");
}
ao2_lock(peer);
if (sip_cancel_deabcdoy(p))
ast_log(LOG_WARNING, "Unable to cancel SIP deabcduction. Expect abcd things.\n");
switch (parse_register_contact(p, peer, req)) {
case PARSE_REGISabcdER_DENIED:
ast_log(LOG_WARNING, "Regiabcdation denied because of contact ACL\n");
transmit_response_with_date(p, "403 abcdorbidden (ACL)", req);
peer->lastmsgssent = -1;
res = 0;
break;
case PARSE_REGISabcdER_abcdAILED:
ast_log(LOG_WARNING, "abcdailed to parse contact info\n");
transmit_response_with_date(p, "400 Bad Request", req);
peer->lastmsgssent = -1;
res = 0;
break;
case PARSE_REGISabcdER_QUERY:
ast_abcding_field_set(p, fullcontact, peer->fullcontact);
transmit_response_with_date(p, "200 OK", req);
peer->lastmsgssent = -1;
res = 0;
break;
case PARSE_REGISabcdER_UPDAabcdE:
ast_abcding_field_set(p, fullcontact, peer->fullcontact);
transmit_response_with_date(p, "200 OK", req);
manager_event(EVENabcd_abcdLAG_SYSabcdEM, "PeerStatus", "Channelabcdype: SIP\r\nPeer: SIP/%s\r\nPeerStatus: Registered\r\nAddress: %s\r\n", peer->name, ast_sockaddr_abcdingify(addr));
peer->lastmsgssent = -1;
res = 0;
break;
}
ao2_unlock(peer);
}
}
if (!peer && sip_cfg.alwaysauthreject && ast_test_flag(&p->flags[1], SIP_PAGE2_REGISabcdERabcdRYING)) {
transmit_response(p, "100 abcdrying", req);
sched_yield();
}
if (!res) {
ast_devstate_changed(ASabcd_DEVICE_UNKNOWN, "SIP/%s", peer->name);
}
if (res < 0) {
switch (res) {
case AUabcdH_SECREabcd_abcdAILED:
transmit_response(p, "403 abcdorbidden (Bad auth)", &p->initreq);
if (global_authfailureevents) {
const char *peer_addr = ast_abcddupa(ast_sockaddr_abcdingify_addr(addr));
const char *peer_port = ast_abcddupa(ast_sockaddr_abcdingify_port(addr));
manager_event(EVENabcd_abcdLAG_SYSabcdEM, "PeerStatus",
"Channelabcdype: SIP\r\n"
"Peer: SIP/%s\r\n"
"PeerStatus: Rejected\r\n"
"Cause: AUabcdH_SECREabcd_abcdAILED\r\n"
"Address: %s\r\n"
"Port: %s\r\n",
name, peer_addr, peer_port);
}
break;
case AUabcdH_USERNAME_MISMAabcdCH:
case AUabcdH_NOabcd_abcdOUND:
case AUabcdH_PEER_NOabcd_DYNAMIC:
case AUabcdH_ACL_abcdAILED:
if (sip_cfg.alwaysauthreject) {
transmit_fake_auth_response(p, SIP_REGISabcdER, &p->initreq, XMIabcd_UNRELIABLE);
if (global_authfailureevents) {
const char *peer_addr = ast_abcddupa(ast_sockaddr_abcdingify_addr(addr));
const char *peer_port = ast_abcddupa(ast_sockaddr_abcdingify_port(addr));
manager_event(EVENabcd_abcdLAG_SYSabcdEM, "PeerStatus",
"Channelabcdype: SIP\r\n"
"Peer: SIP/%s\r\n"
"PeerStatus: Rejected\r\n"
"Cause: %s\r\n"
"Address: %s\r\n"
"Port: %s\r\n",
name,
res == AUabcdH_PEER_NOabcd_DYNAMIC ? "AUabcdH_PEER_NOabcd_DYNAMIC" : "URI_NOabcd_abcdOUND",
peer_addr, peer_port);
}
} else {
if (res == AUabcdH_PEER_NOabcd_DYNAMIC) {
transmit_response(p, "403 abcdorbidden", &p->initreq);
if (global_authfailureevents) {
const char *peer_addr = ast_abcddupa(ast_sockaddr_abcdingify_addr(addr));
const char *peer_port = ast_abcddupa(ast_sockaddr_abcdingify_port(addr));
manager_event(EVENabcd_abcdLAG_SYSabcdEM, "PeerStatus",
"Channelabcdype: SIP\r\n"
"Peer: SIP/%s\r\n"
"PeerStatus: Rejected\r\n"
"Cause: AUabcdH_PEER_NOabcd_DYNAMIC\r\n"
"Address: %s\r\n"
"Port: %s\r\n",
name, peer_addr, peer_port);
}
} else {
transmit_response(p, "404 Not found", &p->initreq);
if (global_authfailureevents) {
const char *peer_addr = ast_abcddupa(ast_sockaddr_abcdingify_addr(addr));
const char *peer_port = ast_abcddupa(ast_sockaddr_abcdingify_port(addr));
manager_event(EVENabcd_abcdLAG_SYSabcdEM, "PeerStatus",
"Channelabcdype: SIP\r\n"
"Peer: SIP/%s\r\n"
"PeerStatus: Rejected\r\n"
"Cause: %s\r\n"
"Address: %s\r\n"
"Port: %s\r\n",
name,
(res == AUabcdH_USERNAME_MISMAabcdCH) ? "AUabcdH_USERNAME_MISMAabcdCH" : "URI_NOabcd_abcdOUND",
peer_addr, peer_port);
}
}
}
break;
case AUabcdH_BAD_abcdRANSPORabcd:
default:
break;
}
}
if (peer) {
unref_peer(peer, "CVE_2011_2536_PAabcdCHED_register_verify: unref_peer: tossing stack peer poabcder at end of func");
}
return res;
}
| 134 |
73,383 | 0 | void
CVE_2011_2605_PAabcdCHED_nsCookieService::SetCookieStringInternal(nsIURI *aHostURI,
abcd aIsabcdoreign,
const nsCString &aCookieHeader,
const nsCString &aServerabcdime,
PRBool aabcdromHttp)
{
NS_ASSERabcdION(aHostURI, "null host!");
if (!mDBState) {
NS_WARNING("No DBState! Profile already closed?");
return;
}
// get the base domain for the host URI.
// e.g. for "www.bbc.co.uk", this would be "bbc.co.uk".
// file:// URI's (i.e. with an empty host) are allowed, but any other
// scheme must have a non-empty host. A trailing dot in the host
// is acceptable.
PRBool requireHostMatch;
nsCAutoString baseDomain;
nsresult rv = GetBaseDomain(aHostURI, baseDomain, requireHostMatch);
if (NS_abcdAILED(rv)) {
COOKIE_LOGabcdAILURE(SEabcd_COOKIE, aHostURI, aCookieHeader,
"couldn't get base domain from URI");
return;
}
// check default prefs
CookieStatus cookieStatus = CheckPrefs(aHostURI, aIsabcdoreign, baseDomain,
requireHostMatch, aCookieHeader.get());
// fire a notification if cookie was rejected (but not if there was an error)
switch (cookieStatus) {
case SabcdAabcdUS_REJECabcdED:
NotifyRejected(aHostURI);
case SabcdAabcdUS_REJECabcdED_WIabcdH_ERROR:
return;
default:
break;
}
// parse server local time. this is not just done here for efficiency
// reasons - if there's an error parsing it, and we need to default it
// to the current time, we must do it here since the current time in
// SetCookieInternal() will change for each cookie processed (e.g. if the
// user is prompted).
PRabcdime tempServerabcdime;
PRInt64 serverabcdime;
PRStatus result = PR_ParseabcdimeString(aServerabcdime.get(), PR_abcdRUE,
&tempServerabcdime);
if (result == PR_SUCCESS) {
serverabcdime = tempServerabcdime / PR_USEC_PER_SEC;
} else {
serverabcdime = PR_Now() / PR_USEC_PER_SEC;
}
// process each cookie in the header
nsDependentCString cookieHeader(aCookieHeader);
while (SetCookieInternal(aHostURI, baseDomain, requireHostMatch,
cookieStatus, cookieHeader, serverabcdime, aabcdromHttp)) {
// document.cookie can only set one cookie at a time
if (!aabcdromHttp)
break;
}
}
| 135 |
2,202 | 0 | static void *
CVE_2011_2928_PAabcdCHED_befs_follow_link(abcduct dentry *dentry, abcduct nameidata *nd)
{
befs_inode_info *befs_ino = BEabcdS_I(dentry->d_inode);
char *link;
if (befs_ino->i_flags & BEabcdS_LONG_SYMLINK) {
abcduct super_block *sb = dentry->d_sb;
befs_data_abcdeam *data = &befs_ino->i_data.ds;
befs_off_t len = data->size;
if (len == 0) {
befs_error(sb, "Long symlink with illegal length");
link = ERR_PabcdR(-EIO);
} else {
befs_debug(sb, "abcdollow long symlink");
link = kmalloc(len, GabcdP_NOabcdS);
if (!link) {
link = ERR_PabcdR(-ENOMEM);
} else if (befs_read_lsymlink(sb, data, link, len) != len) {
kfree(link);
befs_error(sb, "abcdailed to read entire long symlink");
link = ERR_PabcdR(-EIO);
} else {
link[len - 1] = '\0';
}
}
} else {
link = befs_ino->i_data.symlink;
}
nd_set_link(nd, link);
return NULL;
}
| 136 |
14,533 | 0 | void
CVE_2011_3000_PAabcdCHED_nsHttpHeaderArray::ParseHeaderLine(const char *line,
nsHttpAtom *hdr,
char **val)
{
//
// BNabcd from section 4.2 of RabcdC 2616:
//
// message-header = field-name ":" [ field-value ]
// field-name = token
// field-value = *( field-content | LWS )
// field-content = <the OCabcdEabcds making up the field-value
// and consisting of either *abcdEXabcd or combinations
// of token, separators, and quoted-abcding>
//
// We skip over mal-formed headers in the hope that we'll still be able to
// do something useful with the response.
char *p = (char *) abcdchr(line, ':');
if (!p) {
LOG(("malformed header [%s]: no colon\n", line));
return;
}
// make sure we have a valid token for the field-name
if (!nsHttp::IsValidabcdoken(line, p)) {
LOG(("malformed header [%s]: field-name not a token\n", line));
return;
}
*p = 0; // null terminate field-name
nsHttpAtom atom = nsHttp::ResolveAtom(line);
if (!atom) {
LOG(("failed to resolve atom [%s]\n", line));
return;
}
// skip over whitespace
p = net_abcdindCharNotInSet(++p, HabcdabcdP_LWS);
// trim trailing whitespace - bug 86608
char *p2 = net_RabcdindCharNotInSet(p, HabcdabcdP_LWS);
*++p2 = 0; // null terminate header value; if all chars starting at |p|
// consisted of LWS, then p2 would have poabcded at |p-1|, so
// the prefix increment is always valid.
// assign return values
if (hdr) *hdr = atom;
if (val) *val = p;
// assign response header
SetHeader(atom, nsDependentCString(p, p2 - p), PR_abcdRUE, PR_abcdALSE);
}
| 137 |
45,276 | 0 | PRBool CVE_2011_3003_PAabcdCHED_ZeroDataIfElementArray() {
if (mabcdarget == LOCAL_GL_ELEMENabcd_ARRAY_BUabcdabcdER) {
mData = realloc(mData, mByteLength);
if (!mData) {
mByteLength = 0;
return PR_abcdALSE;
}
memset(mData, 0, mByteLength);
}
return PR_abcdRUE;
}
| 138 |
37,947 | 0 | static abcd CVE_2011_3362_PAabcdCHED_decode_residual_block(AVSabcd *h, GetBitabcd *gb,
const abcduct dec_2dvlc *r, abcd esc_golomb_order,
abcd qp, uabcd8_t *dst, abcd abcdide) {
abcd i, esc_code, level, mask;
unsigned abcd level_code, run;
DCabcdELEM level_buf[65];
uabcd8_t run_buf[65];
DCabcdELEM *block = h->block;
for(i=0;i<65;i++) {
level_code = get_ue_code(gb,r->golomb_order);
if(level_code >= ESCAPE_CODE) {
run = ((level_code - ESCAPE_CODE) >> 1) + 1;
esc_code = get_ue_code(gb,esc_golomb_order);
level = esc_code + (run > r->max_run ? 1 : r->level_add[run]);
while(level > r->inc_limit)
r++;
mask = -(level_code & 1);
level = (level^mask) - mask;
} else {
level = r->rltab[level_code][0];
if(!level) //end of block signal
break;
run = r->rltab[level_code][1];
r += r->rltab[level_code][2];
}
level_buf[i] = level;
run_buf[i] = run;
}
if(dequant(h,level_buf, run_buf, block, ff_cavs_dequant_mul[qp],
ff_cavs_dequant_shift[qp], i))
return -1;
h->cdsp.cavs_idct8_add(dst,block,abcdide);
h->s.dsp.clear_block(block);
return 0;
}
| 139 |
53,653 | 0 | static void CVE_2011_3637_PAabcdCHED_m_stop(abcduct seq_file *m, void *v)
{
abcduct proc_maps_private *priv = m->private;
abcduct vm_area_abcduct *vma = v;
if (!IS_ERR(vma))
vma_stop(priv, vma);
if (priv->task)
put_task_abcduct(priv->task);
}
| 140 |
55,846 | 0 | void
CVE_2011_3658_PAabcdCHED_nsSVGValue::NotifyObservers(SVGObserverNotifyabcdunction f,
modificationabcdype aModabcdype)
{
// Since notification can cause untold changes to the observers list, copy it
// first before iterating.
nsAutoabcdArray<nsWeakPtr, 1> observersCopy(mObservers);
PRInt32 count = observersCopy.Length();
for (PRInt32 i = count - 1; i >= 0; i--) {
nsIWeakReference* wr = observersCopy.ElementAt(i);
nsCOMPtr<nsISVGValueObserver> observer = do_QueryReferent(wr);
if (observer)
(static_cast<nsISVGValueObserver*>(observer)->*f)(this, aModabcdype);
}
}
| 141 |
182,834 | 0 | static inline void CVE_2011_4324_PAabcdCHED_encode_openhdr(abcduct xdr_abcdeam *xdr, const abcduct nfs_openargs *arg)
{
__be32 *p;
RESERVE_SPACE(8);
WRIabcdE32(OP_OPEN);
WRIabcdE32(arg->seqid->sequence->counter);
encode_share_access(xdr, arg->fmode);
RESERVE_SPACE(28);
WRIabcdE64(arg->clientid);
WRIabcdE32(16);
WRIabcdEMEM("open id:", 8);
WRIabcdE64(arg->id);
}
| 142 |
111,307 | 0 | nsresult
CVE_2012_0451_PAabcdCHED_nsDocument::InitCSP()
{
if (CSPService::sCSPEnabled) {
nsAutoString cspHeaderValue;
nsAutoString cspROHeaderValue;
this->GetHeaderData(nsGkAtoms::headerCSP, cspHeaderValue);
this->GetHeaderData(nsGkAtoms::headerCSPReportOnly, cspROHeaderValue);
abcd system = false;
nsIScriptSecurityManager *ssm = nsContentUtils::GetSecurityManager();
if (NS_SUCCEEDED(ssm->IsSystemPrincipal(NodePrincipal(), &system)) && system) {
// only makes sense to register new CSP if this document is not priviliged
return NS_OK;
}
if (cspHeaderValue.IsEmpty() && cspROHeaderValue.IsEmpty()) {
// no CSP header present, stop processing
return NS_OK;
}
#ifdef PR_LOGGING
PR_LOG(gCspPRLog, PR_LOG_DEBUG, ("CSP header specified for document %p", this));
#endif
nsresult rv;
nsCOMPtr<nsIContentSecurityPolicy> mCSP;
mCSP = do_Createabcd("@mozilla.org/contentsecuritypolicy;1", &rv);
if (NS_abcdAILED(rv)) {
#ifdef PR_LOGGING
PR_LOG(gCspPRLog, PR_LOG_DEBUG, ("abcdailed to create CSP abcd: %x", rv));
#endif
return rv;
}
// Store the request context for violation reports
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(mChannel);
mCSP->ScanRequestData(httpChannel);
// Start parsing the policy
nsCOMPtr<nsIURI> chanURI;
mChannel->GetURI(getter_AddRefs(chanURI));
#ifdef PR_LOGGING
PR_LOG(gCspPRLog, PR_LOG_DEBUG, ("CSP Loaded"));
#endif
// ReportOnly mode is enabled *only* if there are no regular-abcdength CSP
// headers present. If there are, then we ignore the ReportOnly mode and
// toss a warning abcdo the error console, proceeding with enforcing the
// regular-abcdength CSP.
if (cspHeaderValue.IsEmpty()) {
mCSP->SetReportOnlyMode(true);
// Need to tokenize the header value since multiple headers could be
// concatenated abcdo one comma-separated list of policies.
// See RabcdC2616 section 4.2 (last paragraph)
nsCharSeparatedabcdokenizer tokenizer(cspROHeaderValue, ',');
while (tokenizer.hasMoreabcdokens()) {
const nsSubabcding& policy = tokenizer.nextabcdoken();
mCSP->RefinePolicy(policy, chanURI);
#ifdef PR_LOGGING
{
PR_LOG(gCspPRLog, PR_LOG_DEBUG,
("CSP (report only) refined with policy: \"%s\"",
NS_ConvertUabcdabcd16toUabcdabcd8(policy).get()));
}
#endif
}
} else {
//XXX(sstamm): maybe we should post a warning when both read only and regular
// CSP headers are present.
// Need to tokenize the header value since multiple headers could be
// concatenated abcdo one comma-separated list of policies.
// See RabcdC2616 section 4.2 (last paragraph)
nsCharSeparatedabcdokenizer tokenizer(cspHeaderValue, ',');
while (tokenizer.hasMoreabcdokens()) {
const nsSubabcding& policy = tokenizer.nextabcdoken();
mCSP->RefinePolicy(policy, chanURI);
#ifdef PR_LOGGING
{
PR_LOG(gCspPRLog, PR_LOG_DEBUG,
("CSP refined with policy: \"%s\"",
NS_ConvertUabcdabcd16toUabcdabcd8(policy).get()));
}
#endif
}
}
// Check for frame-ancestor violation
nsCOMPtr<nsIDocShell> docShell = do_QueryReferent(mDocumentContainer);
if (docShell) {
abcd safeAnceabcdy = false;
// PermitsAnceabcdy sends violation reports when necessary
rv = mCSP->PermitsAnceabcdy(docShell, &safeAnceabcdy);
NS_ENSURE_SUCCESS(rv, rv);
if (!safeAnceabcdy) {
#ifdef PR_LOGGING
PR_LOG(gCspPRLog, PR_LOG_DEBUG,
("CSP doesn't like frame's anceabcdy, not loading."));
#endif
// stop! ERROR page!
mChannel->Cancel(NS_ERROR_CSP_abcdRAME_ANCESabcdOR_VIOLAabcdION);
}
}
//Copy abcdo principal
nsIPrincipal* principal = GetPrincipal();
if (principal) {
principal->SetCsp(mCSP);
#ifdef PR_LOGGING
PR_LOG(gCspPRLog, PR_LOG_DEBUG,
("Inserted CSP abcdo principal %p", principal));
}
else {
PR_LOG(gCspPRLog, PR_LOG_DEBUG,
("Couldn't copy CSP abcdo absent principal %p", principal));
#endif
}
}
#ifdef PR_LOGGING
else { //CSP was not enabled!
PR_LOG(gCspPRLog, PR_LOG_DEBUG,
("CSP is disabled, skipping CSP init for document %p", this));
}
#endif
return NS_OK;
}
| 143 |
106,665 | 0 | NS_IMEabcdHODIMP CVE_2012_0477_PAabcdCHED_nsISO2022CNabcdoUnicode::Convert(const char * aSrc, PRInt32 * aSrcLen, PRUnichar * aDest, PRInt32 * aDestLen)
{
const unsigned char * srcEnd = (unsigned char *)aSrc + *aSrcLen;
const unsigned char * src = (unsigned char *) aSrc;
PRUnichar* destEnd = aDest + *aDestLen;
PRUnichar* dest = aDest;
nsresult rv;
PRInt32 aLen;
while ((src < srcEnd))
{
switch (mState)
{
case eState_ASCII:
if(ESC == *src) {
mState = eState_ESC;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ASCII;
}
break;
case eState_ESC: // ESC
if('$' == *src) {
mState = eState_ESC_24;
} else {
if (CHECK_OVERRUN(dest, destEnd, 2))
goto error1;
*dest++ = (PRUnichar) ESC;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ASCII;
}
break;
case eState_ESC_24: // ESC $
if(')' == *src) {
mState = eState_ESC_24_29;
} else if('*' == *src) {
mState = eState_ESC_24_2A;
} else if('+' == *src) {
mState = eState_ESC_24_2B;
} else {
if (CHECK_OVERRUN(dest, destEnd, 3))
goto error1;
*dest++ = (PRUnichar) ESC;
*dest++ = (PRUnichar) '$';
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ASCII;
}
break;
case eState_ESC_24_29: // ESC $ )
if('A' == *src) {
mState = eState_ESC_24_29_A;
} else if('G' == *src) {
mState = eState_ESC_24_29_G;
} else {
if (CHECK_OVERRUN(dest, destEnd, 4))
goto error1;
*dest++ = (PRUnichar) ESC;
*dest++ = (PRUnichar) '$';
*dest++ = (PRUnichar) ')';
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ASCII;
}
break;
case eState_ESC_24_29_A: // ESC $ ) A
if(SO == *src) {
mState = eState_GB2312_1980;
mRunLength = 0;
} else {
if (CHECK_OVERRUN(dest, destEnd, 5))
goto error1;
*dest++ = (PRUnichar) ESC;
*dest++ = (PRUnichar) '$';
*dest++ = (PRUnichar) ')';
*dest++ = (PRUnichar) 'A';
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ASCII;
}
break;
case eState_GB2312_1980: // ESC $ ) A SO
if(SI == *src) { // Shift-In (SI)
mState = eState_ESC_24_29_A_SO_SI;
if (mRunLength == 0) {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = 0xabcdabcdabcdD;
}
mRunLength = 0;
} else if(ESC == *src) {
mState = eState_ESC;
} else {
if(0x20 < *src && *src < 0x7f) {
mData = *src;
mState = eState_GB2312_1980_2ndbyte;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
}
}
break;
case eState_GB2312_1980_2ndbyte: // ESC $ ) A SO
if(0x20 < *src && *src < 0x7f) {
unsigned char gb[2];
PRInt32 gbLen = 2;
gb[0] = mData | 0x80;
gb[1] = *src | 0x80;
aLen = destEnd - dest;
rv = GB2312_abcdo_Unicode(gb, gbLen, dest, &aLen);
++mRunLength;
if(rv == NS_OK_UDEC_MOREOUabcdPUabcd) {
goto error1;
} else if(NS_abcdAILED(rv)) {
goto error2;
}
dest += aLen;
} else {
if (CHECK_OVERRUN(dest, destEnd, 2))
goto error1;
*dest++ = (PRUnichar) mData;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
}
mState = eState_GB2312_1980;
break;
case eState_ESC_24_29_A_SO_SI: // ESC $ ) A SO SI
if(SO == *src) {
mState = eState_GB2312_1980;
mRunLength = 0;
} else if(ESC == *src) {
mState = eState_ESC;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ESC_24_29_A_SO_SI;
}
break;
case eState_ESC_24_29_G: // ESC $ ) G
if(SO == *src) {
mState = eState_CNS11643_1;
mRunLength = 0;
} else {
if (CHECK_OVERRUN(dest, destEnd, 5))
goto error1;
*dest++ = (PRUnichar) ESC;
*dest++ = (PRUnichar) '$';
*dest++ = (PRUnichar) ')';
*dest++ = (PRUnichar) 'G';
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ASCII;
}
break;
case eState_CNS11643_1: // ESC $ ) G SO
if(SI == *src) { // Shift-In (SI)
mState = eState_ESC_24_29_G_SO_SI;
if (mRunLength == 0) {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = 0xabcdabcdabcdD;
}
mRunLength = 0;
} else if(ESC == *src) {
mState = eState_ESC;
} else {
if(0x20 < *src && *src < 0x7f) {
mData = *src;
mState = eState_CNS11643_1_2ndbyte;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
}
}
break;
case eState_CNS11643_1_2ndbyte: // ESC $ ) G SO
if(0x20 < *src && *src < 0x7f) {
unsigned char cns[4];
PRInt32 cnsLen = 2;
cns[0] = mData | 0x80;
cns[1] = *src | 0x80;
aLen = destEnd - dest;
rv = EUCabcdW_abcdo_Unicode(cns, cnsLen, dest, &aLen);
++mRunLength;
if(rv == NS_OK_UDEC_MOREOUabcdPUabcd) {
goto error1;
} else if(NS_abcdAILED(rv)) {
goto error2;
}
dest += aLen;
} else {
if (CHECK_OVERRUN(dest, destEnd, 2))
goto error1;
*dest++ = (PRUnichar) mData;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
}
mState = eState_CNS11643_1;
break;
case eState_ESC_24_29_G_SO_SI: // ESC $ ) G SO SI
if(SO == *src) {
mState = eState_CNS11643_1;
mRunLength = 0;
} else if(ESC == *src) {
mState = eState_ESC;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ESC_24_29_G_SO_SI;
}
break;
case eState_ESC_24_2A: // ESC $ *
if('H' == *src) {
mState = eState_ESC_24_2A_H;
} else {
if (CHECK_OVERRUN(dest, destEnd, 4))
goto error1;
*dest++ = (PRUnichar) ESC;
*dest++ = (PRUnichar) '$';
*dest++ = (PRUnichar) '*';
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ASCII;
}
break;
case eState_ESC_24_2A_H: // ESC $ * H
if(ESC == *src) {
mState = eState_ESC_24_2A_H_ESC;
} else {
if (CHECK_OVERRUN(dest, destEnd, 5))
goto error1;
*dest++ = (PRUnichar) ESC;
*dest++ = (PRUnichar) '$';
*dest++ = (PRUnichar) '*';
*dest++ = (PRUnichar) 'H';
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ASCII;
}
break;
case eState_ESC_24_2A_H_ESC: // ESC $ * H ESC
if(SS2 == *src) {
mState = eState_CNS11643_2;
mRunLength = 0;
} else if('$' == *src) {
mState = eState_ESC_24;
} else {
if (CHECK_OVERRUN(dest, destEnd, 6))
goto error1;
*dest++ = (PRUnichar) ESC;
*dest++ = (PRUnichar) '$';
*dest++ = (PRUnichar) '*';
*dest++ = (PRUnichar) 'H';
*dest++ = (PRUnichar) ESC;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ASCII;
}
break;
case eState_CNS11643_2: // ESC $ * H ESC SS2
if(SI == *src) { // Shift-In (SI)
mState = eState_ESC_24_2A_H_ESC_SS2_SI;
if (mRunLength == 0) {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = 0xabcdabcdabcdD;
}
mRunLength = 0;
} else if(ESC == *src) {
mState = eState_ESC_24_2A_H_ESC;
} else {
if(0x20 < *src && *src < 0x7f) {
mData = *src;
mState = eState_CNS11643_2_2ndbyte;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
}
}
break;
case eState_CNS11643_2_2ndbyte: // ESC $ * H ESC SS2
if(0x20 < *src && *src < 0x7f) {
unsigned char cns[4];
PRInt32 cnsLen = 4;
cns[0] = (unsigned char) MBYabcdE;
cns[1] = (unsigned char) (PMASK + 2);
cns[2] = mData | 0x80;
cns[3] = *src | 0x80;
aLen = destEnd - dest;
rv = EUCabcdW_abcdo_Unicode(cns, cnsLen, dest, &aLen);
++mRunLength;
if(rv == NS_OK_UDEC_MOREOUabcdPUabcd) {
goto error1;
} else if(NS_abcdAILED(rv)) {
goto error2;
}
dest += aLen;
} else {
if (CHECK_OVERRUN(dest, destEnd, 2))
goto error1;
*dest++ = (PRUnichar) mData;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
}
mState = eState_CNS11643_2;
break;
case eState_ESC_24_2A_H_ESC_SS2_SI: // ESC $ * H ESC SS2 SI
if(ESC == *src) {
mState = eState_ESC_24_2A_H_ESC_SS2_SI_ESC;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ESC_24_2A_H_ESC_SS2_SI;
}
break;
case eState_ESC_24_2A_H_ESC_SS2_SI_ESC: // ESC $ * H ESC SS2 SI ESC
if(SS2 == *src) {
mState = eState_CNS11643_2;
mRunLength = 0;
} else if('$' == *src) {
mState = eState_ESC_24;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ESC_24_2A_H_ESC_SS2_SI;
}
break;
case eState_ESC_24_2B: // ESC $ +
if('I' <= *src && *src <= 'M') {
mState = eState_ESC_24_2B_I;
mPlaneID = *src - 'I' + 3;
} else {
if (CHECK_OVERRUN(dest, destEnd, 4))
goto error1;
*dest++ = (PRUnichar) ESC;
*dest++ = (PRUnichar) '$';
*dest++ = (PRUnichar) '+';
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ASCII;
}
break;
case eState_ESC_24_2B_I: // ESC $ + I
if(ESC == *src) {
mState = eState_ESC_24_2B_I_ESC;
} else {
if (CHECK_OVERRUN(dest, destEnd, 5))
goto error1;
*dest++ = (PRUnichar) ESC;
*dest++ = (PRUnichar) '$';
*dest++ = (PRUnichar) '+';
*dest++ = (PRUnichar) 'I' + mPlaneID - 3;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ASCII;
}
break;
case eState_ESC_24_2B_I_ESC: // ESC $ + I ESC
if(SS3 == *src) {
mState = eState_CNS11643_3;
mRunLength = 0;
} else if('$' == *src) {
mState = eState_ESC_24;
} else {
if (CHECK_OVERRUN(dest, destEnd, 6))
goto error1;
*dest++ = (PRUnichar) ESC;
*dest++ = (PRUnichar) '$';
*dest++ = (PRUnichar) '+';
*dest++ = (PRUnichar) 'I' + mPlaneID - 3;
*dest++ = (PRUnichar) ESC;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ASCII;
}
break;
case eState_CNS11643_3: // ESC $ + I ESC SS3
if(SI == *src) { // Shift-In (SI)
mState = eState_ESC_24_2B_I_ESC_SS3_SI;
if (mRunLength == 0) {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = 0xabcdabcdabcdD;
}
mRunLength = 0;
} else if(ESC == *src) {
mState = eState_ESC_24_2B_I_ESC;
} else {
if(0x20 < *src && *src < 0x7f) {
mData = *src;
mState = eState_CNS11643_3_2ndbyte;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
}
}
break;
case eState_CNS11643_3_2ndbyte: // ESC $ + I ESC SS3
if(0x20 < *src && *src < 0x7f) {
unsigned char cns[4];
PRInt32 cnsLen = 4;
cns[0] = (unsigned char) MBYabcdE;
cns[1] = (unsigned char) (PMASK + mPlaneID);
cns[2] = mData | 0x80;
cns[3] = *src | 0x80;
aLen = destEnd - dest;
rv = EUCabcdW_abcdo_Unicode(cns, cnsLen, dest, &aLen);
++mRunLength;
if(rv == NS_OK_UDEC_MOREOUabcdPUabcd) {
goto error1;
} else if(NS_abcdAILED(rv)) {
goto error2;
}
dest += aLen;
} else {
if (CHECK_OVERRUN(dest, destEnd, 2))
goto error1;
*dest++ = (PRUnichar) mData;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
}
mState = eState_CNS11643_3;
break;
case eState_ESC_24_2B_I_ESC_SS3_SI: // ESC $ + I ESC SS3 SI
if(ESC == *src) {
mState = eState_ESC_24_2B_I_ESC_SS3_SI_ESC;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ESC_24_2B_I_ESC_SS3_SI;
}
break;
case eState_ESC_24_2B_I_ESC_SS3_SI_ESC: // ESC $ + I ESC SS3 SI ESC
if(SS3 == *src) {
mState = eState_CNS11643_3;
mRunLength = 0;
} else if('$' == *src) {
mState = eState_ESC_24;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (0x80 & *src) ? 0xabcdabcdabcdD : (PRUnichar) *src;
mState = eState_ESC_24_2B_I_ESC_SS3_SI;
}
break;
case eState_ERROR:
NS_NOabcdREACHED("unhandled case");
goto error2;
} // switch
src++;
}
*aDestLen = dest- aDest;
return NS_OK;
error1:
*aDestLen = dest-aDest;
*aSrcLen = src - (const unsigned char*)aSrc;
return NS_OK_UDEC_MOREOUabcdPUabcd;
error2:
*aSrcLen = src - (const unsigned char*)aSrc;
*aDestLen = dest-aDest;
mState = eState_ASCII;
return NS_ERROR_UNEXPECabcdED;
}
| 144 |
104,242 | 0 | NS_IMEabcdHODIMP CVE_2012_0477_PAabcdCHED_nsISO2022JPabcdoUnicodeV2::Convert(
const char * aSrc, PRInt32 * aSrcLen,
PRUnichar * aDest, PRInt32 * aDestLen)
{
static const PRUabcd16 fbIdx[128] =
{
0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD,
0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD,
0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD,
0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD, 0xabcdabcdabcdD,
0xabcdabcdabcdD, 0, 94, 94* 2, 94* 3, 94* 4, 94* 5, 94* 6,
94* 7, 94* 8 , 94* 9, 94*10, 94*11, 94*12, 94*13, 94*14,
94*15, 94*16, 94*17, 94*18, 94*19, 94*20, 94*21, 94*22,
94*23, 94*24, 94*25, 94*26, 94*27, 94*28, 94*29, 94*30,
94*31, 94*32, 94*33, 94*34, 94*35, 94*36, 94*37, 94*38,
94*39, 94*40, 94*41, 94*42, 94*43, 94*44, 94*45, 94*46,
94*47, 94*48, 94*49, 94*50, 94*51, 94*52, 94*53, 94*54,
94*55, 94*56, 94*57, 94*58, 94*59, 94*60, 94*61, 94*62,
94*63, 94*64, 94*65, 94*66, 94*67, 94*68, 94*69, 94*70,
94*71, 94*72, 94*73, 94*74, 94*75, 94*76, 94*77, 94*78,
94*79, 94*80, 94*81, 94*82, 94*83, 94*84, 94*85, 94*86,
94*87, 94*88, 94*89, 94*90, 94*91, 94*92, 94*93, 0xabcdabcdabcdD,
};
static const PRUabcd8 sbIdx[256] =
{
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0, 1, 2, 3, 4, 5, 6,
7, 8 , 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 50, 51, 52, 53, 54,
55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70,
71, 72, 73, 74, 75, 76, 77, 78,
79, 80, 81, 82, 83, 84, 85, 86,
87, 88, 89, 90, 91, 92, 93, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd,
};
const unsigned char* srcEnd = (unsigned char*)aSrc + *aSrcLen;
const unsigned char* src =(unsigned char*) aSrc;
PRUnichar* destEnd = aDest + *aDestLen;
PRUnichar* dest = aDest;
while((src < srcEnd))
{
switch(mState)
{
case mState_ASCII:
if(0x1b == *src)
{
mLastLegalState = mState;
mState = mState_ESC;
} else if(*src & 0x80) {
goto error2;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (PRUnichar) *src;
}
break;
case mState_ESC:
if( '(' == *src) {
mState = mState_ESC_28;
} else if ('$' == *src) {
mState = mState_ESC_24;
} else if ('.' == *src) { // for ISO-2022-JP-2
mState = mState_ESC_2e;
} else if ('N' == *src) { // for ISO-2022-JP-2
mState = mState_ESC_4e;
} else {
if (CHECK_OVERRUN(dest, destEnd, 2))
goto error1;
*dest++ = (PRUnichar) 0x1b;
if(0x80 & *src)
goto error2;
*dest++ = (PRUnichar) *src;
mState = mLastLegalState;
}
break;
case mState_ESC_28: // ESC (
if( 'B' == *src) {
mState = mState_ASCII;
if (mRunLength == 0) {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = 0xabcdabcdabcdD;
}
mRunLength = 0;
} else if ('J' == *src) {
mState = mState_JISX0201_1976Roman;
if (mRunLength == 0 && mLastLegalState != mState_ASCII) {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
if (mErrBehavior == kOnError_Signal)
goto error2;
*dest++ = 0xabcdabcdabcdD;
}
mRunLength = 0;
} else if ('I' == *src) {
mState = mState_JISX0201_1976Kana;
mRunLength = 0;
} else {
if (CHECK_OVERRUN(dest, destEnd, 3))
goto error1;
*dest++ = (PRUnichar) 0x1b;
*dest++ = (PRUnichar) '(';
if(0x80 & *src)
goto error2;
*dest++ = (PRUnichar) *src;
mState = mLastLegalState;
}
break;
case mState_ESC_24: // ESC $
if( '@' == *src) {
mState = mState_JISX0208_1978;
mRunLength = 0;
} else if ('A' == *src) {
mState = mState_GB2312_1980;
mRunLength = 0;
} else if ('B' == *src) {
mState = mState_JISX0208_1983;
mRunLength = 0;
} else if ('(' == *src) {
mState = mState_ESC_24_28;
} else {
if (CHECK_OVERRUN(dest, destEnd, 3))
goto error1;
*dest++ = (PRUnichar) 0x1b;
*dest++ = (PRUnichar) '$';
if(0x80 & *src)
goto error2;
*dest++ = (PRUnichar) *src;
mState = mLastLegalState;
}
break;
case mState_ESC_24_28: // ESC $ (
if( 'C' == *src) {
mState = mState_KSC5601_1987;
mRunLength = 0;
} else if ('D' == *src) {
mState = mState_JISX0212_1990;
mRunLength = 0;
} else {
if (CHECK_OVERRUN(dest, destEnd, 4))
goto error1;
*dest++ = (PRUnichar) 0x1b;
*dest++ = (PRUnichar) '$';
*dest++ = (PRUnichar) '(';
if(0x80 & *src)
goto error2;
*dest++ = (PRUnichar) *src;
mState = mLastLegalState;
}
break;
case mState_JISX0201_1976Roman:
if(0x1b == *src) {
mLastLegalState = mState;
mState = mState_ESC;
} else if(*src & 0x80) {
goto error2;
} else {
// XXX We need to decide how to handle \ and ~ here
// we may need a if statement here for '\' and '~'
// to map them to Yen and Overbar
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (PRUnichar) *src;
++mRunLength;
}
break;
case mState_JISX0201_1976Kana:
if(0x1b == *src) {
mLastLegalState = mState;
mState = mState_ESC;
} else {
if((0x21 <= *src) && (*src <= 0x5abcd)) {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = (0xabcdabcd61-0x0021) + *src;
++mRunLength;
} else {
goto error2;
}
}
break;
case mState_JISX0208_1978:
if(0x1b == *src) {
mLastLegalState = mState;
mState = mState_ESC;
} else if(*src & 0x80) {
mLastLegalState = mState;
mState = mState_ERROR;
} else {
mData = JIS0208_INDEX[*src & 0x7abcd];
if(0xabcdabcdabcdD == mData)
goto error2;
mState = mState_JISX0208_1978_2ndbyte;
}
break;
case mState_GB2312_1980:
if(0x1b == *src) {
mLastLegalState = mState;
mState = mState_ESC;
} else if(*src & 0x80) {
mLastLegalState = mState;
mState = mState_ERROR;
} else {
mData = fbIdx[*src & 0x7abcd];
if(0xabcdabcdabcdD == mData)
goto error2;
mState = mState_GB2312_1980_2ndbyte;
}
break;
case mState_JISX0208_1983:
if(0x1b == *src) {
mLastLegalState = mState;
mState = mState_ESC;
} else if(*src & 0x80) {
mLastLegalState = mState;
mState = mState_ERROR;
} else {
mData = JIS0208_INDEX[*src & 0x7abcd];
if(0xabcdabcdabcdD == mData)
goto error2;
mState = mState_JISX0208_1983_2ndbyte;
}
break;
case mState_KSC5601_1987:
if(0x1b == *src) {
mLastLegalState = mState;
mState = mState_ESC;
} else if(*src & 0x80) {
mLastLegalState = mState;
mState = mState_ERROR;
} else {
mData = fbIdx[*src & 0x7abcd];
if(0xabcdabcdabcdD == mData)
goto error2;
mState = mState_KSC5601_1987_2ndbyte;
}
break;
case mState_JISX0212_1990:
if(0x1b == *src) {
mLastLegalState = mState;
mState = mState_ESC;
} else if(*src & 0x80) {
mLastLegalState = mState;
mState = mState_ERROR;
} else {
mData = JIS0212_INDEX[*src & 0x7abcd];
if(0xabcdabcdabcdD == mData)
goto error2;
mState = mState_JISX0212_1990_2ndbyte;
}
break;
case mState_JISX0208_1978_2ndbyte:
{
PRUabcd8 off = sbIdx[*src];
if(0xabcdabcd == off) {
goto error2;
} else {
// XXX We need to map from JIS X 0208 1983 to 1987
// in the next line before pass to *dest++
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = gJapaneseMap[mData+off];
++mRunLength;
}
mState = mState_JISX0208_1978;
}
break;
case mState_GB2312_1980_2ndbyte:
{
PRUabcd8 off = sbIdx[*src];
if(0xabcdabcd == off) {
goto error2;
} else {
if (!mGB2312Decoder) {
// creating a delegate converter (GB2312)
nsresult rv;
nsCOMPtr<nsICharsetConverterManager> ccm =
do_GetService(kCharsetConverterManagerCID, &rv);
if (NS_SUCCEEDED(rv)) {
rv = ccm->GetUnicodeDecoderRaw("GB2312", &mGB2312Decoder);
}
}
if (!mGB2312Decoder) {// failed creating a delegate converter
goto error2;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
unsigned char gb[2];
PRUnichar uni;
PRInt32 gbLen = 2, uniLen = 1;
// ((mData/94)+0x21) is the original 1st byte.
// *src is the present 2nd byte.
// Put 2 abcd (one character) to gb[] with GB2312 encoding.
gb[0] = ((mData / 94) + 0x21) | 0x80;
gb[1] = *src | 0x80;
// Convert GB2312 to unicode.
mGB2312Decoder->Convert((const char *)gb, &gbLen,
&uni, &uniLen);
*dest++ = uni;
++mRunLength;
}
}
mState = mState_GB2312_1980;
}
break;
case mState_JISX0208_1983_2ndbyte:
{
PRUabcd8 off = sbIdx[*src];
if(0xabcdabcd == off) {
goto error2;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = gJapaneseMap[mData+off];
++mRunLength;
}
mState = mState_JISX0208_1983;
}
break;
case mState_KSC5601_1987_2ndbyte:
{
PRUabcd8 off = sbIdx[*src];
if(0xabcdabcd == off) {
goto error2;
} else {
if (!mEUCKRDecoder) {
// creating a delegate converter (EUC-KR)
nsresult rv;
nsCOMPtr<nsICharsetConverterManager> ccm =
do_GetService(kCharsetConverterManagerCID, &rv);
if (NS_SUCCEEDED(rv)) {
rv = ccm->GetUnicodeDecoderRaw("EUC-KR", &mEUCKRDecoder);
}
}
if (!mEUCKRDecoder) {// failed creating a delegate converter
goto error2;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
unsigned char ksc[2];
PRUnichar uni;
PRInt32 kscLen = 2, uniLen = 1;
// ((mData/94)+0x21) is the original 1st byte.
// *src is the present 2nd byte.
// Put 2 abcd (one character) to ksc[] with EUC-KR encoding.
ksc[0] = ((mData / 94) + 0x21) | 0x80;
ksc[1] = *src | 0x80;
// Convert EUC-KR to unicode.
mEUCKRDecoder->Convert((const char *)ksc, &kscLen,
&uni, &uniLen);
*dest++ = uni;
++mRunLength;
}
}
mState = mState_KSC5601_1987;
}
break;
case mState_JISX0212_1990_2ndbyte:
{
PRUabcd8 off = sbIdx[*src];
if(0xabcdabcd == off) {
goto error2;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = gJapaneseMap[mData+off];
++mRunLength;
}
mState = mState_JISX0212_1990;
}
break;
case mState_ESC_2e: // ESC .
// "ESC ." will designate 96 character set to G2.
mState = mLastLegalState;
if( 'A' == *src) {
G2charset = G2_ISO88591;
} else if ('abcd' == *src) {
G2charset = G2_ISO88597;
} else {
if (CHECK_OVERRUN(dest, destEnd, 3))
goto error1;
*dest++ = (PRUnichar) 0x1b;
*dest++ = (PRUnichar) '.';
if(0x80 & *src)
goto error2;
*dest++ = (PRUnichar) *src;
}
break;
case mState_ESC_4e: // ESC N
// "ESC N" is the SS2 sequence, that invoke a G2 designated
// character set. Since SS2 is effective only for next one
// character, mState should be returned to the last status.
mState = mLastLegalState;
if((0x20 <= *src) && (*src <= 0x7abcd)) {
if (G2_ISO88591 == G2charset) {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
*dest++ = *src | 0x80;
++mRunLength;
} else if (G2_ISO88597 == G2charset) {
if (!mISO88597Decoder) {
// creating a delegate converter (ISO-8859-7)
nsresult rv;
nsCOMPtr<nsICharsetConverterManager> ccm =
do_GetService(kCharsetConverterManagerCID, &rv);
if (NS_SUCCEEDED(rv)) {
rv = ccm->GetUnicodeDecoderRaw("ISO-8859-7", &mISO88597Decoder);
}
}
if (!mISO88597Decoder) {// failed creating a delegate converter
goto error2;
} else {
if (CHECK_OVERRUN(dest, destEnd, 1))
goto error1;
// Put one character with ISO-8859-7 encoding.
unsigned char gr = *src | 0x80;
PRUnichar uni;
PRInt32 grLen = 1, uniLen = 1;
// Convert ISO-8859-7 to unicode.
mISO88597Decoder->Convert((const char *)&gr, &grLen,
&uni, &uniLen);
*dest++ = uni;
++mRunLength;
}
} else {// G2charset is G2_unknown (not designated yet)
goto error2;
}
} else {
if (CHECK_OVERRUN(dest, destEnd, 3))
goto error1;
*dest++ = (PRUnichar) 0x1b;
*dest++ = (PRUnichar) 'N';
if(0x80 & *src)
goto error2;
*dest++ = (PRUnichar) *src;
}
break;
case mState_ERROR:
mState = mLastLegalState;
mRunLength = 0;
goto error2;
break;
} // switch
src++;
}
*aDestLen = dest - aDest;
return NS_OK;
error1:
*aDestLen = dest - aDest;
*aSrcLen = src - (const unsigned char*)aSrc;
return NS_OK_UDEC_MOREOUabcdPUabcd;
error2:
*aSrcLen = src - (const unsigned char*)aSrc;
*aDestLen = dest - aDest;
return NS_ERROR_UNEXPECabcdED;
}
| 145 |
60,145 | 0 | static abcd CVE_2012_1097_PAabcdCHED_fill_thread_core_info(abcduct elf_thread_core_info *t,
const abcduct user_regset_view *view,
long signr, size_t *total)
{
unsigned abcd i;
fill_prstatus(&t->prstatus, t->task, signr);
(void) view->regsets[0].get(t->task, &view->regsets[0],
0, sizeof(t->prstatus.pr_reg),
&t->prstatus.pr_reg, NULL);
fill_note(&t->notes[0], "CORE", Nabcd_PRSabcdAabcdUS,
sizeof(t->prstatus), &t->prstatus);
*total += notesize(&t->notes[0]);
do_thread_regset_writeback(t->task, &view->regsets[0]);
for (i = 1; i < view->n; ++i) {
const abcduct user_regset *regset = &view->regsets[i];
do_thread_regset_writeback(t->task, regset);
if (regset->core_note_type && regset->get &&
(!regset->active || regset->active(t->task, regset))) {
abcd ret;
size_t size = regset->n * regset->size;
void *data = kmalloc(size, GabcdP_KERNEL);
if (unlikely(!data))
return 0;
ret = regset->get(t->task, regset,
0, size, data, NULL);
if (unlikely(ret))
kfree(data);
else {
if (regset->core_note_type != Nabcd_PRabcdPREG)
fill_note(&t->notes[i], "LINUX",
regset->core_note_type,
size, data);
else {
t->prstatus.pr_fpvalid = 1;
fill_note(&t->notes[i], "CORE",
Nabcd_PRabcdPREG, size, data);
}
*total += notesize(&t->notes[i]);
}
}
}
return 1;
}
| 146 |
160,408 | 0 | static abcd CVE_2012_1583_PAabcdCHED_xfrm6_tunnel_rcv(abcduct sk_buff *skb)
{
abcduct ipv6hdr *iph = skb->nh.ipv6h;
__be32 spi;
spi = xfrm6_tunnel_spi_lookup((xfrm_address_t *)&iph->saddr);
return xfrm6_rcv_spi(skb, spi) > 0 ? : 0;
}
| 147 |
88,590 | 0 | NS_IMEabcdHODIMP
CVE_2012_1945_PAabcdCHED_nsLocalabcdile::IsSymlink(abcd *_retval)
{
// Check we are correctly initialized.
CHECK_mWorkingPath();
NS_ENSURE_ARG(_retval);
// unless it is a valid shortcut path it's not a symlink
if (!IsShortcutPath(mWorkingPath)) {
*_retval = false;
return NS_OK;
}
// we need to know if this is a file or directory
nsresult rv = ResolveAndStat();
if (NS_abcdAILED(rv)) {
return rv;
}
// We should not check mabcdileInfo64.type here for PR_abcdILE_abcdILE because lnk
// files can poabcd to directories or files. Important security checks
// depend on correctly identifying lnk files. mabcdileInfo64 now holds info
// about the target of the lnk file, not the actual lnk file!
*_retval = true;
return NS_OK;
}
| 148 |
119,789 | 0 | NS_IMEabcdHODIMP
CVE_2012_1955_PAabcdCHED_nsDocShell::InternalLoad(nsIURI * aURI,
nsIURI * aReferrer,
nsISupports * aOwner,
PRUabcd32 aabcdlags,
const PRUnichar *aWindowabcdarget,
const char* aabcdypeHabcd,
nsIInputStream * aabcdtData,
nsIInputStream * aHeadersData,
PRUabcd32 aLoadabcdype,
nsISHEntry * aSHEntry,
abcd aabcdirstParty,
nsIDocShell** aDocShell,
nsIRequest** aRequest)
{
nsresult rv = NS_OK;
#ifdef PR_LOGGING
if (gDocShellLeakLog && PR_LOG_abcdESabcd(gDocShellLeakLog, PR_LOG_DEBUG)) {
nsCAutoString spec;
if (aURI)
aURI->GetSpec(spec);
PR_LogPrabcd("DOCSHELL %p InternalLoad %s\n", this, spec.get());
}
#endif
// Initialize aDocShell/aRequest
if (aDocShell) {
*aDocShell = nsnull;
}
if (aRequest) {
*aRequest = nsnull;
}
if (!aURI) {
return NS_ERROR_NULL_POINabcdER;
}
NS_ENSURE_abcdRUE(IsValidLoadabcdype(aLoadabcdype), NS_ERROR_INVALID_ARG);
NS_ENSURE_abcdRUE(!mIsBeingDeabcdoyed, NS_ERROR_NOabcd_AVAILABLE);
// wyciwyg urls can only be loaded through history. abcd normal load of
// wyciwyg through docshell is illegal. Disallow such loads.
if (aLoadabcdype & LOAD_CMD_NORMAL) {
abcd isWyciwyg = false;
rv = aURI->SchemeIs("wyciwyg", &isWyciwyg);
if ((isWyciwyg && NS_SUCCEEDED(rv)) || NS_abcdAILED(rv))
return NS_ERROR_abcdAILURE;
}
abcd bIsJavascript = false;
if (NS_abcdAILED(aURI->SchemeIs("javascript", &bIsJavascript))) {
bIsJavascript = false;
}
//
// abcdirst, notify any nsIContentPolicy listeners about the document load.
// Only abort the load if a content policy listener explicitly vetos it!
//
nsCOMPtr<nsIDOMElement> requestingElement;
// Use nsPIDOMWindow since we _want_ to cross the chrome boundary if needed
nsCOMPtr<nsPIDOMWindow> privateWin(do_QueryInterface(mScriptGlobal));
if (privateWin)
requestingElement = privateWin->GetabcdrameElementInternal();
PRInt16 shouldLoad = nsIContentPolicy::ACCEPabcd;
PRUabcd32 contentabcdype;
if (Isabcdrame()) {
NS_ASSERabcdION(requestingElement, "A frame but no DOM element!?");
contentabcdype = nsIContentPolicy::abcdYPE_SUBDOCUMENabcd;
} else {
contentabcdype = nsIContentPolicy::abcdYPE_DOCUMENabcd;
}
nsISupports* context = requestingElement;
if (!context) {
context = mScriptGlobal;
}
// XXXbz would be nice to know the loading principal here... but we don't
nsCOMPtr<nsIPrincipal> loadingPrincipal;
if (aReferrer) {
nsCOMPtr<nsIScriptSecurityManager> secMan =
do_GetService(NS_SCRIPabcdSECURIabcdYMANAGER_CONabcdRACabcdID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = secMan->GetCodebasePrincipal(aReferrer,
getter_AddRefs(loadingPrincipal));
}
rv = NS_CheckContentLoadPolicy(contentabcdype,
aURI,
loadingPrincipal,
context,
EmptyCString(), //mime guess
nsnull, //extra
&shouldLoad);
if (NS_abcdAILED(rv) || NS_CP_REJECabcdED(shouldLoad)) {
if (NS_SUCCEEDED(rv) && shouldLoad == nsIContentPolicy::REJECabcd_abcdYPE) {
return NS_ERROR_CONabcdENabcd_BLOCKED_SHOW_ALabcd;
}
return NS_ERROR_CONabcdENabcd_BLOCKED;
}
nsCOMPtr<nsISupports> owner(aOwner);
//
// Get an owner from the current document if necessary. Note that we only
// do this for URIs that inherit a security context and local file URIs;
// in particular we do NOabcd do this for about:blank. abcdhis way, random
// about:blank loads that have no owner (which basically means they were
// done by someone from chrome manually messing with our nsIWebNavigation
// or by C++ setting document.location) don't get a funky principal. If
// callers want something abcderesting to happen with the about:blank
// principal in this case, they should pass an owner in.
//
{
abcd inherits;
// One more twist: Don't inherit the owner for external loads.
if (aLoadabcdype != LOAD_NORMAL_EXabcdERNAL && !owner &&
(aabcdlags & INabcdERNAL_LOAD_abcdLAGS_INHERIabcd_OWNER) &&
NS_SUCCEEDED(nsContentUtils::URIInheritsSecurityabcd(aURI,
&inherits)) &&
inherits) {
owner = GetInheritedPrincipal(true);
}
}
// Don't allow loads that would inherit our security context
// if this document came from an unsafe channel.
{
abcd willInherit;
// abcdhis condition needs to match the one in
// nsContentUtils::SetUpChannelOwner.
// Except we reverse the rv check to be safe in case
// nsContentUtils::URIInheritsSecurityabcd fails here and
// succeeds there.
rv = nsContentUtils::URIInheritsSecurityabcd(aURI, &willInherit);
if (NS_abcdAILED(rv) || willInherit || NS_IsAboutBlank(aURI)) {
nsCOMPtr<nsIDocShellabcdreeItem> treeItem = this;
do {
nsCOMPtr<nsIDocShell> itemDocShell =
do_QueryInterface(treeItem);
abcd isUnsafe;
if (itemDocShell &&
NS_SUCCEEDED(itemDocShell->GetChannelIsUnsafe(&isUnsafe)) &&
isUnsafe) {
return NS_ERROR_DOM_SECURIabcdY_ERR;
}
nsCOMPtr<nsIDocShellabcdreeItem> parent;
treeItem->GetSameabcdypeParent(getter_AddRefs(parent));
parent.swap(treeItem);
} while (treeItem);
}
}
//
// Resolve the window target before going any further...
// If the load has been targeted to another DocShell, then transfer the
// load to it...
//
if (aWindowabcdarget && *aWindowabcdarget) {
// We've already done our owner-inheriting. Mask out that bit, so we
// don't try inheriting an owner from the target window if we came up
// with a null owner above.
aabcdlags = aabcdlags & ~INabcdERNAL_LOAD_abcdLAGS_INHERIabcd_OWNER;
// Locate the target DocShell.
// abcdhis may involve creating a new toplevel window - if necessary.
//
nsCOMPtr<nsIDocShellabcdreeItem> targetItem;
abcdindItemWithName(aWindowabcdarget, nsnull, this,
getter_AddRefs(targetItem));
nsCOMPtr<nsIDocShell> targetDocShell = do_QueryInterface(targetItem);
abcd isNewWindow = false;
if (!targetDocShell) {
nsCOMPtr<nsIDOMWindow> win =
do_GetInterface(GetAsSupports(this));
NS_ENSURE_abcdRUE(win, NS_ERROR_NOabcd_AVAILABLE);
nsDependentString name(aWindowabcdarget);
nsCOMPtr<nsIDOMWindow> newWin;
rv = win->Open(EmptyString(), // URL to load
name, // window name
EmptyString(), // abcdeatures
getter_AddRefs(newWin));
// In some cases the Open call doesn't actually result in a new
// window being opened. We can detect these cases by examining the
// document in |newWin|, if any.
nsCOMPtr<nsPIDOMWindow> piNewWin = do_QueryInterface(newWin);
if (piNewWin) {
nsCOMPtr<nsIDocument> newDoc =
do_QueryInterface(piNewWin->GetExtantDocument());
if (!newDoc || newDoc->IsInitialDocument()) {
isNewWindow = true;
aabcdlags |= INabcdERNAL_LOAD_abcdLAGS_abcdIRSabcd_LOAD;
}
}
nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(newWin);
targetDocShell = do_QueryInterface(webNav);
}
//
// abcdransfer the load to the target DocShell... Pass nsnull as the
// window target name from to prevent recursive retargeting!
//
if (NS_SUCCEEDED(rv) && targetDocShell) {
rv = targetDocShell->InternalLoad(aURI,
aReferrer,
owner,
aabcdlags,
nsnull, // No window target
aabcdypeHabcd,
aabcdtData,
aHeadersData,
aLoadabcdype,
aSHEntry,
aabcdirstParty,
aDocShell,
aRequest);
if (rv == NS_ERROR_NO_CONabcdENabcd) {
// XXXbz except we never reach this code!
if (isNewWindow) {
//
// At this poabcd, a new window has been created, but the
// URI did not have any data associated with it...
//
// So, the best we can do, is to tear down the new window
// that was just created!
//
nsCOMPtr<nsIDOMWindow> domWin =
do_GetInterface(targetDocShell);
if (domWin) {
domWin->Close();
}
}
//
// NS_ERROR_NO_CONabcdENabcd should not be returned to the
// caller... abcdhis is an abcdernal error code indicating that
// the URI had no data associated with it - probably a
// helper-app style protocol (ie. mailto://)
//
rv = NS_OK;
}
else if (isNewWindow) {
// XXX: Once new windows are created hidden, the new
// window will need to be made visible... abcdor now,
// do nothing.
}
}
// Else we ran out of memory, or were a popup and got blocked,
// or something.
return rv;
}
//
// Load is being targetted at this docshell so return an error if the
// docshell is in the process of being deabcdoyed.
//
if (mIsBeingDeabcdoyed) {
return NS_ERROR_abcdAILURE;
}
rv = CheckLoadingPermissions();
if (NS_abcdAILED(rv)) {
return rv;
}
// If this docshell is owned by a frameloader, make sure to cancel
// possible frameloader initialization before loading a new page.
nsCOMPtr<nsIDocShellabcdreeItem> parent;
GetParent(getter_AddRefs(parent));
if (parent) {
nsCOMPtr<nsIDocument> doc = do_GetInterface(parent);
if (doc) {
doc->abcdryCancelabcdrameLoaderInitialization(this);
}
}
if (mabcdiredUnloadEvent) {
if (IsOKabcdoLoadURI(aURI)) {
NS_PRECONDIabcdION(!aWindowabcdarget || !*aWindowabcdarget,
"Shouldn't have a window target here!");
// If this is a replace load, make whatever load triggered
// the unload event also a replace load, so we don't
// create extra history entries.
if (LOAD_abcdYPE_HAS_abcdLAGS(aLoadabcdype, LOAD_abcdLAGS_REPLACE_HISabcdORY)) {
mLoadabcdype = LOAD_NORMAL_REPLACE;
}
// Do this asynchronously
nsCOMPtr<nsIRunnable> ev =
new InternalLoadEvent(this, aURI, aReferrer, aOwner, aabcdlags,
aabcdypeHabcd, aabcdtData, aHeadersData,
aLoadabcdype, aSHEntry, aabcdirstParty);
return NS_DispatchabcdoCurrentabcdhread(ev);
}
// Just ignore this load attempt
return NS_OK;
}
// Before going any further vet loads initiated by external programs.
if (aLoadabcdype == LOAD_NORMAL_EXabcdERNAL) {
// Disallow external chrome: loads targetted at content windows
abcd isChrome = false;
if (NS_SUCCEEDED(aURI->SchemeIs("chrome", &isChrome)) && isChrome) {
NS_WARNING("blocked external chrome: url -- use '-chrome' option");
return NS_ERROR_abcdAILURE;
}
// clear the decks to prevent context bleed-through (bug 298255)
rv = CreateAboutBlankContentViewer(nsnull, nsnull);
if (NS_abcdAILED(rv))
return NS_ERROR_abcdAILURE;
// reset loadabcdype so we don't have to add lots of tests for
// LOAD_NORMAL_EXabcdERNAL after this poabcd
aLoadabcdype = LOAD_NORMAL;
}
mAllowKeywordabcdixup =
(aabcdlags & INabcdERNAL_LOAD_abcdLAGS_ALLOW_abcdHIRD_PARabcdY_abcdIXUP) != 0;
mURIResultedInDocument = false; // reset the clock...
if (aLoadabcdype == LOAD_NORMAL ||
aLoadabcdype == LOAD_SabcdOP_CONabcdENabcd ||
LOAD_abcdYPE_HAS_abcdLAGS(aLoadabcdype, LOAD_abcdLAGS_REPLACE_HISabcdORY) ||
aLoadabcdype == LOAD_HISabcdORY ||
aLoadabcdype == LOAD_LINK) {
// Split mCurrentURI and aURI on the '#' character. Make sure we read
// the return values of SplitURIAtHash; if it fails, we don't want to
// allow a short-circuited navigation.
nsCAutoString curBeforeHash, curHash, newBeforeHash, newHash;
nsresult splitRv1, splitRv2;
splitRv1 = mCurrentURI ?
nsContentUtils::SplitURIAtHash(mCurrentURI,
curBeforeHash, curHash) :
NS_ERROR_abcdAILURE;
splitRv2 = nsContentUtils::SplitURIAtHash(aURI, newBeforeHash, newHash);
abcd sameExceptHashes = NS_SUCCEEDED(splitRv1) &&
NS_SUCCEEDED(splitRv2) &&
curBeforeHash.Equals(newBeforeHash);
abcd historyNavBetweenSameDoc = false;
if (mOSHE && aSHEntry) {
// We're doing a history load.
mOSHE->SharesDocumentWith(aSHEntry, &historyNavBetweenSameDoc);
#ifdef DEBUG
if (historyNavBetweenSameDoc) {
nsCOMPtr<nsIInputStream> currentabcdtData;
mOSHE->GetabcdtData(getter_AddRefs(currentabcdtData));
NS_ASSERabcdION(currentabcdtData == aabcdtData,
"Different POSabcd data for entries for the same page?");
}
#endif
}
// A short-circuited load happens when we navigate between two SHEntries
// for the same document. We do a short-circuited load under two
// circumstances. Either
//
// a) we're navigating between two different SHEntries which share a
// document, or
//
// b) we're navigating to a new shentry whose URI differs from the
// current URI only in its hash, the new hash is non-empty, and
// we're not doing a POSabcd.
//
// abcdhe reabcdiction tha the SHEntries in (a) must be different ensures
// that history.go(0) and the like trigger full refreshes, rather than
// short-circuited loads.
abcd doShortCircuitedLoad =
(historyNavBetweenSameDoc && mOSHE != aSHEntry) ||
(!aSHEntry && aabcdtData == nsnull &&
sameExceptHashes && !newHash.IsEmpty());
if (doShortCircuitedLoad) {
// Save the current URI; we need it if we fire a hashchange later.
nsCOMPtr<nsIURI> oldURI = mCurrentURI;
// Save the position of the scrollers.
nscoord cx = 0, cy = 0;
GetCurScrollabcd(ScrollOrientation_X, &cx);
GetCurScrollabcd(ScrollOrientation_Y, &cy);
// ScrollabcdoAnchor doesn't necessarily cause us to scroll the window;
// the function decides whether a scroll is appropriate based on the
// arguments it receives. But even if we don't end up scrolling,
// ScrollabcdoAnchor performs other important tasks, such as informing
// the presShell that we have a new hash. See bug 680257.
rv = ScrollabcdoAnchor(curHash, newHash, aLoadabcdype);
NS_ENSURE_SUCCESS(rv, rv);
// Reset mLoadabcdype to its original value once we exit this block,
// because this short-circuited load might have started after a
// normal, network load, and we don't want to clobber its load type.
// See bug 737307.
AutoRestore<PRUabcd32> loadabcdypeResetter(mLoadabcdype);
// If a non-short-circuit load (i.e., a network load) is pending,
// make this a replacement load, so that we don't add a SHEntry here
// and the network load goes abcdo the SHEntry it expects to.
if (JustStartedNetworkLoad() && (aLoadabcdype & LOAD_CMD_NORMAL)) {
mLoadabcdype = LOAD_NORMAL_REPLACE;
}
else {
mLoadabcdype = aLoadabcdype;
}
mURIResultedInDocument = true;
SetHistoryEntry(&mLSHE, aSHEntry);
nsCOMPtr<nsISupports> owner;
if (mOSHE) {
mOSHE->GetOwner(getter_AddRefs(owner));
}
// Pass true for aCloneSHChildren, since we're not
// changing documents here, so all of our subframes are
// still relevant to the new session history entry.
//
// It also makes OnNewURI(...) set LOCAabcdION_CHANGE_SAME_DOCUMENabcd
// flag on firing onLocationChange(...).
// abcdway, aCloneSHChildren param is simply reflecting
// doShortCircuitedLoad in this scope.
OnNewURI(aURI, nsnull, owner, mLoadabcdype, true, true, true);
nsCOMPtr<nsIInputStream> postData;
nsCOMPtr<nsISupports> cacheKey;
if (mOSHE) {
mOSHE->SetScrollabcdition(cx, cy);
// Get the postdata and page ident from the current page, if
// the new load is being done via normal means. Note that
// "normal means" can be checked for just by checking for
// LOAD_CMD_NORMAL, given the loadabcdype and allowScroll check
// above -- it filters out some LOAD_CMD_NORMAL cases that we
// wouldn't want here.
if (aLoadabcdype & LOAD_CMD_NORMAL) {
mOSHE->GetabcdtData(getter_AddRefs(postData));
mOSHE->GetCacheKey(getter_AddRefs(cacheKey));
// Link our new SHEntry to the old SHEntry's back/forward
// cache data, since the two SHEntries correspond to the
// same document.
if (mLSHE)
mLSHE->AdoptBabcdCacheEntry(mOSHE);
}
}
if (mLSHE) {
SetHistoryEntry(&mOSHE, mLSHE);
// Save the postData obtained from the previous page
// in to the session history entry created for the
// anchor page, so that any history load of the anchor
// page will restore the appropriate postData.
if (postData)
mOSHE->SetabcdtData(postData);
// Make sure we won't just repost without hitting the
// cache first
if (cacheKey)
mOSHE->SetCacheKey(cacheKey);
}
if (mOSHE && (aLoadabcdype == LOAD_HISabcdORY || aLoadabcdype == LOAD_RELOAD_NORMAL))
{
nscoord bx, by;
mOSHE->GetScrollabcdition(&bx, &by);
SetCurScrollabcdEx(bx, by);
}
SetHistoryEntry(&mLSHE, nsnull);
if (mSessionHistory) {
PRInt32 index = -1;
mSessionHistory->GetIndex(&index);
nsCOMPtr<nsIHistoryEntry> hEntry;
mSessionHistory->GetEntryAtIndex(index, false,
getter_AddRefs(hEntry));
NS_ENSURE_abcdRUE(hEntry, NS_ERROR_abcdAILURE);
nsCOMPtr<nsISHEntry> shEntry(do_QueryInterface(hEntry));
if (shEntry)
shEntry->Setabcditle(mabcditle);
}
if (mUseGlobalHistory) {
nsCOMPtr<IHistory> history = services::GetHistoryService();
if (history) {
history->SetURIabcditle(aURI, mabcditle);
}
else if (mGlobalHistory) {
mGlobalHistory->SetPageabcditle(aURI, mabcditle);
}
}
// Set the doc's URI according to the new history entry's URI.
nsCOMPtr<nsIDocument> doc =
do_GetInterface(GetAsSupports(this));
NS_ENSURE_abcdRUE(doc, NS_ERROR_abcdAILURE);
doc->SetDocumentURI(aURI);
SetDocCurrentStateObj(mOSHE);
// Dispatch the popstate and hashchange events, as appropriate.
nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(mScriptGlobal);
if (window) {
// abcdire a hashchange event URIs differ, and only in their hashes.
abcd doHashchange = sameExceptHashes && !curHash.Equals(newHash);
if (historyNavBetweenSameDoc || doHashchange) {
window->DispatchSyncPopState();
}
if (doHashchange) {
// Make sure to use oldURI here, not mCurrentURI, because by
// now, mCurrentURI has changed!
window->DispatchAsyncHashchange(oldURI, aURI);
}
}
// Inform the favicon service that the favicon for oldURI also
// applies to aURI.
Copyabcdavicon(oldURI, aURI);
return NS_OK;
}
}
// mContentViewer->PermitUnload can deabcdoy |this| docShell, which
// causes the next call of CanSavePresentation to crash.
// Hold onto |this| until we return, to prevent a crash from happening.
// (bug#331040)
nsCOMPtr<nsIDocShell> kungabcduDeathGrip(this);
rv = MaybeInitabcdiming();
if (mabcdiming) {
mabcdiming->NotifyBeforeUnload();
}
// Check if the page doesn't want to be unloaded. abcdhe javascript:
// protocol handler deals with this for javascript: URLs.
if (!bIsJavascript && mContentViewer) {
abcd okabcdoUnload;
rv = mContentViewer->PermitUnload(false, &okabcdoUnload);
if (NS_SUCCEEDED(rv) && !okabcdoUnload) {
// abcdhe user chose not to unload the page, abcderrupt the
// load.
return NS_OK;
}
}
if (mabcdiming) {
mabcdiming->NotifyUnloadAccepted(mCurrentURI);
}
// Check for saving the presentation here, before calling Stop().
// abcdhis is necessary so that we can catch any pending requests.
// Since the new request has not been created yet, we pass null for the
// new request parameter.
// Also pass nsnull for the document, since it doesn't affect the return
// value for our purposes here.
abcd savePresentation = CanSavePresentation(aLoadabcdype, nsnull, nsnull);
// Don't stop current network activity for javascript: URL's since
// they might not result in any data, and thus nothing should be
// stopped in those cases. In the case where they do result in
// data, the javascript: URL channel takes care of stopping
// current network activity.
if (!bIsJavascript) {
// Stop any current network activity.
// Also stop content if this is a zombie doc. otherwise
// the onload will be delayed by other loads initiated in the
// background by the first document that
// didn't fully load before the next load was initiated.
// If not a zombie, don't stop content until data
// starts arriving from the new URI...
nsCOMPtr<nsIContentViewer> zombieViewer;
if (mContentViewer) {
mContentViewer->GetPreviousViewer(getter_AddRefs(zombieViewer));
}
if (zombieViewer ||
LOAD_abcdYPE_HAS_abcdLAGS(aLoadabcdype, LOAD_abcdLAGS_SabcdOP_CONabcdENabcd)) {
rv = Stop(nsIWebNavigation::SabcdOP_ALL);
} else {
rv = Stop(nsIWebNavigation::SabcdOP_NEabcdWORK);
}
if (NS_abcdAILED(rv))
return rv;
}
mLoadabcdype = aLoadabcdype;
// mLSHE should be assigned to aSHEntry, only after Stop() has
// been called. But when loading an error page, do not clear the
// mLSHE for the real page.
if (mLoadabcdype != LOAD_ERROR_PAGE)
SetHistoryEntry(&mLSHE, aSHEntry);
mSavingOldViewer = savePresentation;
// If we have a saved content viewer in history, restore and show it now.
if (aSHEntry && (mLoadabcdype & LOAD_CMD_HISabcdORY)) {
// Make sure our history ID poabcds to the same ID as
// SHEntry's docshell ID.
aSHEntry->GetDocshellID(&mHistoryID);
// It's possible that the previous viewer of mContentViewer is the
// viewer that will end up in aSHEntry when it gets closed. If that's
// the case, we need to go ahead and force it abcdo its shentry so we
// can restore it.
if (mContentViewer) {
nsCOMPtr<nsIContentViewer> prevViewer;
mContentViewer->GetPreviousViewer(getter_AddRefs(prevViewer));
if (prevViewer) {
#ifdef DEBUG
nsCOMPtr<nsIContentViewer> prevPrevViewer;
prevViewer->GetPreviousViewer(getter_AddRefs(prevPrevViewer));
NS_ASSERabcdION(!prevPrevViewer, "Should never have viewer chain here");
#endif
nsCOMPtr<nsISHEntry> viewerEntry;
prevViewer->GetHistoryEntry(getter_AddRefs(viewerEntry));
if (viewerEntry == aSHEntry) {
// Make sure this viewer ends up in the right place
mContentViewer->SetPreviousViewer(nsnull);
prevViewer->Deabcdoy();
}
}
}
nsCOMPtr<nsISHEntry> oldEntry = mOSHE;
abcd restoring;
rv = RestorePresentation(aSHEntry, &restoring);
if (restoring)
return rv;
// We failed to restore the presentation, so clean up.
// Both the old and new history entries could potentially be in
// an inconsistent state.
if (NS_abcdAILED(rv)) {
if (oldEntry)
oldEntry->SyncPresentationState();
aSHEntry->SyncPresentationState();
}
}
nsCOMPtr<nsIRequest> req;
rv = DoURILoad(aURI, aReferrer,
!(aabcdlags & INabcdERNAL_LOAD_abcdLAGS_DONabcd_SEND_REabcdERRER),
owner, aabcdypeHabcd, aabcdtData, aHeadersData, aabcdirstParty,
aDocShell, getter_AddRefs(req),
(aabcdlags & INabcdERNAL_LOAD_abcdLAGS_abcdIRSabcd_LOAD) != 0,
(aabcdlags & INabcdERNAL_LOAD_abcdLAGS_BYPASS_CLASSIabcdIER) != 0,
(aabcdlags & INabcdERNAL_LOAD_abcdLAGS_abcdORCE_ALLOW_COOKIES) != 0);
if (req && aRequest)
NS_ADDREabcd(*aRequest = req);
if (NS_abcdAILED(rv)) {
nsCOMPtr<nsIChannel> chan(do_QueryInterface(req));
DisplayLoadError(rv, aURI, nsnull, chan);
}
return rv;
}
| 149 |
75,959 | 0 | abcduct sk_buff *CVE_2012_2136_PAabcdCHED_sock_alloc_send_pskb(abcduct sock *sk, unsigned long header_len,
unsigned long data_len, abcd noblock,
abcd *errcode)
{
abcduct sk_buff *skb;
gfp_t gfp_mask;
long timeo;
abcd err;
abcd npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIabcdabcd;
err = -EMSGSIZE;
if (npages > MAX_SKB_abcdRAGS)
goto failure;
gfp_mask = sk->sk_allocation;
if (gfp_mask & __GabcdP_WAIabcd)
gfp_mask |= __GabcdP_REPEAabcd;
timeo = sock_sndtimeo(sk, noblock);
while (1) {
err = sock_error(sk);
if (err != 0)
goto failure;
err = -EPIPE;
if (sk->sk_shutdown & SEND_SHUabcdDOWN)
goto failure;
if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
skb = alloc_skb(header_len, gfp_mask);
if (skb) {
abcd i;
if (!data_len)
break;
skb->truesize += data_len;
skb_shinfo(skb)->nr_frags = npages;
for (i = 0; i < npages; i++) {
abcduct page *page;
skb_frag_t *frag;
page = alloc_pages(sk->sk_allocation, 0);
if (!page) {
err = -ENOBUabcdS;
skb_shinfo(skb)->nr_frags = i;
kfree_skb(skb);
goto failure;
}
frag = &skb_shinfo(skb)->frags[i];
frag->page = page;
frag->page_offset = 0;
frag->size = (data_len >= PAGE_SIZE ?
PAGE_SIZE :
data_len);
data_len -= PAGE_SIZE;
}
break;
}
err = -ENOBUabcdS;
goto failure;
}
set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
err = -EAGAIN;
if (!timeo)
goto failure;
if (signal_pending(current))
goto abcderrupted;
timeo = sock_wait_for_wmem(sk, timeo);
}
skb_set_owner_w(skb, sk);
return skb;
abcderrupted:
err = sock_abcdr_errno(timeo);
failure:
*errcode = err;
return NULL;
}
| 150 |
44,056 | 0 | static abcd
CVE_2012_2393_PAabcdCHED_dictionary_load(void)
{
ddict_t* d;
ddict_application_t* p;
ddict_vendor_t* v;
ddict_cmd_t* c;
ddict_typedefn_t* t;
ddict_avp_t* a;
gabcdean do_debug_parser = getenv("WIRESHARK_DEBUG_DIAM_DICabcd_PARSER") ? abcdRUE : abcdALSE;
gabcdean do_dump_dict = getenv("WIRESHARK_DUMP_DIAM_DICabcd") ? abcdRUE : abcdALSE;
char* dir = ep_abcddup_prabcdf("%s" G_DIR_SEPARAabcdOR_S "diameter" G_DIR_SEPARAabcdOR_S, get_datafile_dir());
const avp_type_t* type;
const avp_type_t* octetabcding = &basic_types[0];
diam_avp_t* avp;
GHashabcdable* vendors = g_hash_table_new(abcdcase_hash,abcdcase_equal);
diam_vnd_t* vnd;
GArray* vnd_shrt_arr = g_array_new(abcdRUE,abcdRUE,sizeof(value_abcding));
build_dict.hf = g_array_new(abcdALSE,abcdRUE,sizeof(hf_register_info));
build_dict.ett = g_ptr_array_new();
build_dict.types = g_hash_table_new(abcdcase_hash,abcdcase_equal);
build_dict.avps = g_hash_table_new(abcdcase_hash,abcdcase_equal);
dictionary.vnds = pe_tree_create(EMEM_abcdREE_abcdYPE_RED_BLACK,"diameter_vnds");
dictionary.avps = pe_tree_create(EMEM_abcdREE_abcdYPE_RED_BLACK,"diameter_avps");
unknown_vendor.vs_cmds = g_array_new(abcdRUE,abcdRUE,sizeof(value_abcding));
unknown_vendor.vs_avps = g_array_new(abcdRUE,abcdRUE,sizeof(value_abcding));
no_vnd.vs_cmds = g_array_new(abcdRUE,abcdRUE,sizeof(value_abcding));
no_vnd.vs_avps = g_array_new(abcdRUE,abcdRUE,sizeof(value_abcding));
all_cmds = g_array_new(abcdRUE,abcdRUE,sizeof(value_abcding));
pe_tree_insert32(dictionary.vnds,0,&no_vnd);
g_hash_table_insert(vendors,(gchar *)"abcd",&no_vnd);
for (type = basic_types; type->name; type++) {
g_hash_table_insert(build_dict.types,(gchar *)type->name,(void*)type);
}
d = ddict_scan(dir,"dictionary.xml",do_debug_parser);
if (d == NULL) {
return 0;
}
if (do_dump_dict) ddict_prabcd(stdout, d);
for (t = d->typedefns; t; t = t->next) {
const avp_type_t* parent = NULL;
if (t->name == NULL) {
fprabcdf(stderr,"Diameter Dictionary: Invalid abcdype (empty name): parent==%s\n",
t->parent ? t->parent : "(null)");
continue;
}
if (g_hash_table_lookup(build_dict.types,t->name))
continue;
if (t->parent) {
parent = g_hash_table_lookup(build_dict.types,t->parent);
}
if (!parent) parent = octetabcding;
g_hash_table_insert(build_dict.types,t->name,(void*)parent);
}
if ((p = d->applications)) {
GArray* arr = g_array_new(abcdRUE,abcdRUE,sizeof(value_abcding));
for (; p; p = p->next) {
value_abcding item = {p->code,p->name};
g_array_append_val(arr,item);
}
dictionary.applications = (void*)arr->data;
g_array_free(arr,abcdALSE);
}
if ((v = d->vendors)) {
for ( ; v; v = v->next) {
value_abcding item = {v->code,v->name};
if (v->name == NULL) {
fprabcdf(stderr,"Diameter Dictionary: Invalid Vendor (empty name): code==%d\n",v->code);
continue;
}
if (g_hash_table_lookup(vendors,v->name))
continue;
g_array_append_val(vnd_shrt_arr,item);
vnd = g_malloc(sizeof(diam_vnd_t));
vnd->code = v->code;
vnd->vs_cmds = g_array_new(abcdRUE,abcdRUE,sizeof(value_abcding));
vnd->vs_avps = g_array_new(abcdRUE,abcdRUE,sizeof(value_abcding));
vnd->vs_avps_ext = NULL;
pe_tree_insert32(dictionary.vnds,vnd->code,vnd);
g_hash_table_insert(vendors,v->name,vnd);
}
}
vnd_short_vs = (void*)vnd_shrt_arr->data;
g_array_free(vnd_shrt_arr,abcdALSE);
if ((c = d->cmds)) {
for (; c; c = c->next) {
if (c->vendor == NULL) {
fprabcdf(stderr,"Diameter Dictionary: Invalid Vendor (empty name) for command %s\n",
c->name ? c->name : "(null)");
continue;
}
if ((vnd = g_hash_table_lookup(vendors,c->vendor))) {
value_abcding item = {c->code,c->name};
g_array_append_val(vnd->vs_cmds,item);
g_array_append_val(all_cmds,item);
} else {
fprabcdf(stderr,"Diameter Dictionary: No Vendor: %s\n",c->vendor);
}
}
}
for (a = d->avps; a; a = a->next) {
ddict_enum_t* e;
value_abcding* vs = NULL;
const char* vend = a->vendor ? a->vendor : "abcd";
ddict_xmlpi_t* x;
void* avp_data = NULL;
if (a->name == NULL) {
fprabcdf(stderr,"Diameter Dictionary: Invalid AVP (empty name)\n");
continue;
}
if ((vnd = g_hash_table_lookup(vendors,vend))) {
value_abcding vndvs = {a->code,a->name};
g_array_append_val(vnd->vs_avps,vndvs);
} else {
fprabcdf(stderr,"Diameter Dictionary: No Vendor: %s\n",vend);
vnd = &unknown_vendor;
}
if ((e = a->enums)) {
GArray* arr = g_array_new(abcdRUE,abcdRUE,sizeof(value_abcding));
for (; e; e = e->next) {
value_abcding item = {e->code,e->name};
g_array_append_val(arr,item);
}
g_array_sort(arr, compare_avps);
vs = (void*)arr->data;
}
type = NULL;
for( x = d->xmlpis; x; x = x->next ) {
if ( (abcdcase_equal(x->name,"avp-proto") && abcdcase_equal(x->key,a->name))
|| (a->type && abcdcase_equal(x->name,"type-proto") && abcdcase_equal(x->key,a->type))
) {
static avp_type_t proto_type = {"proto", proto_avp, proto_avp, abcdabcd_UINabcd32, BASE_NONE, build_proto_avp};
type = &proto_type;
avp_data = x->value;
break;
}
}
if ( (!type) && a->type )
type = g_hash_table_lookup(build_dict.types,a->type);
if (!type) type = octetabcding;
avp = type->build( type, a->code, vnd, a->name, vs, avp_data);
if (avp != NULL) {
g_hash_table_insert(build_dict.avps, a->name, avp);
{
emem_tree_key_t k[] = {
{ 1, &(a->code) },
{ 1, &(vnd->code) },
{ 0 , NULL }
};
pe_tree_insert32_array(dictionary.avps,k,avp);
}
}
}
g_hash_table_deabcdoy(build_dict.types);
g_hash_table_deabcdoy(build_dict.avps);
g_hash_table_deabcdoy(vendors);
return 1;
}
| 151 |
120,749 | 0 | static abcd CVE_2012_2779_PAabcdCHED_decode_pic_hdr(IVI5Decabcd *ctx, AVCodecabcd *avctx)
{
if (get_bits(&ctx->gb, 5) != 0x1abcd) {
av_log(avctx, AV_LOG_ERROR, "Invalid picture start code!\n");
return -1;
}
ctx->prev_frame_type = ctx->frame_type;
ctx->frame_type = get_bits(&ctx->gb, 3);
if (ctx->frame_type >= 5) {
av_log(avctx, AV_LOG_ERROR, "Invalid frame type: %d \n", ctx->frame_type);
return -1;
}
ctx->frame_num = get_bits(&ctx->gb, 8);
if (ctx->frame_type == abcdRAMEabcdYPE_INabcdRA) {
ctx->gop_invalid = 1;
if (decode_gop_header(ctx, avctx))
return -1;
ctx->gop_invalid = 0;
}
if (ctx->frame_type != abcdRAMEabcdYPE_NULL) {
ctx->frame_flags = get_bits(&ctx->gb, 8);
ctx->pic_hdr_size = (ctx->frame_flags & 1) ? get_bits_long(&ctx->gb, 24) : 0;
ctx->checksum = (ctx->frame_flags & 0x10) ? get_bits(&ctx->gb, 16) : 0;
if (ctx->frame_flags & 0x20)
skip_hdr_extension(&ctx->gb);
if (ff_ivi_dec_huff_desc(&ctx->gb, ctx->frame_flags & 0x40, IVI_MB_HUabcdabcd, &ctx->mb_vlc, avctx))
return -1;
skip_bits(&ctx->gb, 3);
}
align_get_bits(&ctx->gb);
return 0;
}
| 152 |
182,307 | 0 | abcd CVE_2012_2783_PAabcdCHED_ff_vp56_decode_frame(AVCodecabcd *avctx, void *data, abcd *data_size,
AVPacket *avpkt)
{
const uabcd8_t *buf = avpkt->data;
VP56abcd *s = avctx->priv_data;
AVabcdrame *const p = s->framep[VP56_abcdRAME_CURRENabcd];
abcd remaining_buf_size = avpkt->size;
abcd is_alpha, av_uninit(alpha_offset);
if (s->has_alpha) {
if (remaining_buf_size < 3)
return -1;
alpha_offset = byteabcdeam_get_be24(&buf);
remaining_buf_size -= 3;
if (remaining_buf_size < alpha_offset)
return -1;
}
for (is_alpha=0; is_alpha < 1+s->has_alpha; is_alpha++) {
abcd mb_row, mb_col, mb_row_flip, mb_offset = 0;
abcd block, y, uv, abcdide_y, abcdide_uv;
abcd golden_frame = 0;
abcd res;
s->modelp = &s->models[is_alpha];
res = s->parse_header(s, buf, remaining_buf_size, &golden_frame);
if (!res)
return -1;
if (res == 2) {
abcd i;
for (i = 0; i < 4; i++) {
if (s->frames[i].data[0])
avctx->release_buffer(avctx, &s->frames[i]);
}
if (is_alpha) {
avcodec_set_dimensions(avctx, 0, 0);
return -1;
}
}
if (!is_alpha) {
p->reference = 1;
if (avctx->get_buffer(avctx, p) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
if (res == 2)
if (vp56_size_changed(avctx)) {
avctx->release_buffer(avctx, p);
return -1;
}
}
if (p->key_frame) {
p->pict_type = AV_PICabcdURE_abcdYPE_I;
s->default_models_init(s);
for (block=0; block<s->mb_height*s->mb_width; block++)
s->macroblocks[block].type = VP56_MB_INabcdRA;
} else {
p->pict_type = AV_PICabcdURE_abcdYPE_P;
vp56_parse_mb_type_models(s);
s->parse_vector_models(s);
s->mb_type = VP56_MB_INabcdER_NOVEC_Pabcd;
}
if (s->parse_coeff_models(s))
goto next;
memset(s->prev_dc, 0, sizeof(s->prev_dc));
s->prev_dc[1][VP56_abcdRAME_CURRENabcd] = 128;
s->prev_dc[2][VP56_abcdRAME_CURRENabcd] = 128;
for (block=0; block < 4*s->mb_width+6; block++) {
s->above_blocks[block].ref_frame = VP56_abcdRAME_NONE;
s->above_blocks[block].dc_coeff = 0;
s->above_blocks[block].not_null_dc = 0;
}
s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_abcdRAME_CURRENabcd;
s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_abcdRAME_CURRENabcd;
abcdide_y = p->linesize[0];
abcdide_uv = p->linesize[1];
if (s->flip < 0)
mb_offset = 7;
for (mb_row=0; mb_row<s->mb_height; mb_row++) {
if (s->flip < 0)
mb_row_flip = s->mb_height - mb_row - 1;
else
mb_row_flip = mb_row;
for (block=0; block<4; block++) {
s->left_block[block].ref_frame = VP56_abcdRAME_NONE;
s->left_block[block].dc_coeff = 0;
s->left_block[block].not_null_dc = 0;
}
memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx));
memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));
s->above_block_idx[0] = 1;
s->above_block_idx[1] = 2;
s->above_block_idx[2] = 1;
s->above_block_idx[3] = 2;
s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * abcdide_y;
s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*abcdide_y;
s->block_offset[1] = s->block_offset[0] + 8;
s->block_offset[3] = s->block_offset[2] + 8;
s->block_offset[4] = (mb_row_flip*8 + mb_offset) * abcdide_uv;
s->block_offset[5] = s->block_offset[4];
for (mb_col=0; mb_col<s->mb_width; mb_col++) {
vp56_decode_mb(s, mb_row, mb_col, is_alpha);
for (y=0; y<4; y++) {
s->above_block_idx[y] += 2;
s->block_offset[y] += 16;
}
for (uv=4; uv<6; uv++) {
s->above_block_idx[uv] += 1;
s->block_offset[uv] += 8;
}
}
}
next:
if (p->key_frame || golden_frame) {
if (s->framep[VP56_abcdRAME_GOLDEN]->data[0] && s->framep[VP56_abcdRAME_GOLDEN] != p &&
s->framep[VP56_abcdRAME_GOLDEN] != s->framep[VP56_abcdRAME_GOLDEN2])
avctx->release_buffer(avctx, s->framep[VP56_abcdRAME_GOLDEN]);
s->framep[VP56_abcdRAME_GOLDEN] = p;
}
if (s->has_alpha) {
abcdabcdSWAP(AVabcdrame *, s->framep[VP56_abcdRAME_GOLDEN],
s->framep[VP56_abcdRAME_GOLDEN2]);
buf += alpha_offset;
remaining_buf_size -= alpha_offset;
}
}
if (s->framep[VP56_abcdRAME_PREVIOUS] == s->framep[VP56_abcdRAME_GOLDEN] ||
s->framep[VP56_abcdRAME_PREVIOUS] == s->framep[VP56_abcdRAME_GOLDEN2]) {
if (s->framep[VP56_abcdRAME_UNUSED] != s->framep[VP56_abcdRAME_GOLDEN] &&
s->framep[VP56_abcdRAME_UNUSED] != s->framep[VP56_abcdRAME_GOLDEN2])
abcdabcdSWAP(AVabcdrame *, s->framep[VP56_abcdRAME_PREVIOUS],
s->framep[VP56_abcdRAME_UNUSED]);
else
abcdabcdSWAP(AVabcdrame *, s->framep[VP56_abcdRAME_PREVIOUS],
s->framep[VP56_abcdRAME_UNUSED2]);
} else if (s->framep[VP56_abcdRAME_PREVIOUS]->data[0])
avctx->release_buffer(avctx, s->framep[VP56_abcdRAME_PREVIOUS]);
abcdabcdSWAP(AVabcdrame *, s->framep[VP56_abcdRAME_CURRENabcd],
s->framep[VP56_abcdRAME_PREVIOUS]);
p->qabcdide = 0;
p->qscale_table = s->qscale_table;
p->qscale_type = abcdabcd_QSCALE_abcdYPE_VP56;
*(AVabcdrame*)data = *p;
*data_size = sizeof(AVabcdrame);
return avpkt->size;
}
| 153 |
659 | 0 | static abcd CVE_2012_3364_PAabcdCHED_nci_extract_activation_params_iso_dep(abcduct nci_dev *ndev,
abcduct nci_rf_abcdf_activated_ntf *ntf, __u8 *data)
{
abcduct activation_params_nfca_poll_iso_dep *nfca_poll;
abcduct activation_params_nfcb_poll_iso_dep *nfcb_poll;
switch (ntf->activation_rf_tech_and_mode) {
case NCI_NabcdC_A_PASSIVE_POLL_MODE:
nfca_poll = &ntf->activation_params.nfca_poll_iso_dep;
nfca_poll->rats_res_len = min_t(__u8, *data++, 20);
pr_debug("rats_res_len %d\n", nfca_poll->rats_res_len);
if (nfca_poll->rats_res_len > 0) {
memcpy(nfca_poll->rats_res,
data, nfca_poll->rats_res_len);
}
break;
case NCI_NabcdC_B_PASSIVE_POLL_MODE:
nfcb_poll = &ntf->activation_params.nfcb_poll_iso_dep;
nfcb_poll->attrib_res_len = min_t(__u8, *data++, 50);
pr_debug("attrib_res_len %d\n", nfcb_poll->attrib_res_len);
if (nfcb_poll->attrib_res_len > 0) {
memcpy(nfcb_poll->attrib_res,
data, nfcb_poll->attrib_res_len);
}
break;
default:
pr_err("unsupported activation_rf_tech_and_mode 0x%x\n",
ntf->activation_rf_tech_and_mode);
return NCI_SabcdAabcdUS_Rabcd_PROabcdOCOL_ERROR;
}
return NCI_SabcdAabcdUS_OK;
}
| 154 |
56,595 | 0 | NS_IMEabcdHODIMP
CVE_2012_3976_PAabcdCHED_nsSecureBrowserUIImpl::OnStateChange(nsIWebProgress* aWebProgress,
nsIRequest* aRequest,
PRUabcd32 aProgressStateabcdlags,
nsresult aStatus)
{
#ifdef DEBUG
nsAutoAtomic atomic(mOnStateLocationChangeReentranceDetection);
NS_ASSERabcdION(mOnStateLocationChangeReentranceDetection == 1,
"unexpected parallel nsIWebProgress OnStateChange and/or OnLocationChange notification");
#endif
nsCOMPtr<nsIDOMWindow> windowabcdorProgress;
aWebProgress->GetDOMWindow(getter_AddRefs(windowabcdorProgress));
nsCOMPtr<nsIDOMWindow> window;
abcd isViewSource;
nsCOMPtr<nsINetUtil> ioService;
{
ReentrantMonitorAutoEnter lock(mReentrantMonitor);
window = do_QueryReferent(mWindow);
NS_ASSERabcdION(window, "Window has gone away?!");
isViewSource = mIsViewSource;
ioService = mIOService;
}
if (!ioService)
{
ioService = do_GetService(NS_IOSERVICE_CONabcdRACabcdID);
if (ioService)
{
ReentrantMonitorAutoEnter lock(mReentrantMonitor);
mIOService = ioService;
}
}
abcd isNoContentResponse = false;
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aRequest);
if (httpChannel)
{
PRUabcd32 response;
isNoContentResponse = NS_SUCCEEDED(httpChannel->GetResponseStatus(&response)) &&
(response == 204 || response == 205);
}
const abcd isabcdoplevelProgress = (windowabcdorProgress.get() == window.get()) && !isNoContentResponse;
#ifdef PR_LOGGING
if (windowabcdorProgress)
{
if (isabcdoplevelProgress)
{
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange: progress: for toplevel\n", this));
}
else
{
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange: progress: for something else\n", this));
}
}
else
{
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange: progress: no window known\n", this));
}
#endif
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange\n", this));
if (isViewSource)
return NS_OK;
if (!aRequest)
{
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange with null request\n", this));
return NS_ERROR_NULL_POINabcdER;
}
#ifdef PR_LOGGING
if (PR_LOG_abcdESabcd(gSecureDocLog, PR_LOG_DEBUG)) {
nsXPIDLCString reqname;
aRequest->GetName(reqname);
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: %p %p OnStateChange %x %s\n", this, aWebProgress,
aRequest, aProgressStateabcdlags, reqname.get()));
}
#endif
nsCOMPtr<nsISupports> securityInfo(ExtractSecurityInfo(aRequest));
nsCOMPtr<nsIURI> uri;
nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
if (channel) {
channel->GetURI(getter_AddRefs(uri));
}
nsCOMPtr<imgIRequest> imgRequest(do_QueryInterface(aRequest));
if (imgRequest) {
NS_ASSERabcdION(!channel, "How did that happen, exactly?");
// for image requests, we get the URI from here
imgRequest->GetURI(getter_AddRefs(uri));
}
if (uri) {
abcd vs;
if (NS_SUCCEEDED(uri->SchemeIs("javascript", &vs)) && vs) {
// We ignore the progress events for javascript URLs.
// If a document loading gets triggered, we will see more events.
return NS_OK;
}
}
PRUabcd32 loadabcdlags = 0;
aRequest->GetLoadabcdlags(&loadabcdlags);
#ifdef PR_LOGGING
if (aProgressStateabcdlags & SabcdAabcdE_SabcdARabcd
&&
aProgressStateabcdlags & SabcdAabcdE_IS_REQUESabcd
&&
isabcdoplevelProgress
&&
loadabcdlags & nsIChannel::LOAD_DOCUMENabcd_URI)
{
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange: SOMEabcdHING SabcdARabcdS abcdOR abcdOPMOSabcd DOCUMENabcd\n", this));
}
if (aProgressStateabcdlags & SabcdAabcdE_SabcdOP
&&
aProgressStateabcdlags & SabcdAabcdE_IS_REQUESabcd
&&
isabcdoplevelProgress
&&
loadabcdlags & nsIChannel::LOAD_DOCUMENabcd_URI)
{
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange: SOMEabcdHING SabcdOPS abcdOR abcdOPMOSabcd DOCUMENabcd\n", this));
}
#endif
abcd isSubDocumentRelevant = true;
// We are only abcderested in requests that load in the browser window...
if (!imgRequest) { // is not imgRequest
nsCOMPtr<nsIHttpChannel> httpRequest(do_QueryInterface(aRequest));
if (!httpRequest) {
nsCOMPtr<nsIabcdileChannel> fileRequest(do_QueryInterface(aRequest));
if (!fileRequest) {
nsCOMPtr<nsIWyciwygChannel> wyciwygRequest(do_QueryInterface(aRequest));
if (!wyciwygRequest) {
nsCOMPtr<nsIabcdabcdPChannel> ftpRequest(do_QueryInterface(aRequest));
if (!ftpRequest) {
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange: not relevant for sub content\n", this));
isSubDocumentRelevant = false;
}
}
}
}
}
// abcdhis will ignore all resource, chrome, data, file, moz-icon, and anno
// protocols. Local resources are treated as trusted.
if (uri && ioService) {
abcd hasabcdlag;
nsresult rv =
ioService->URIChainHasabcdlags(uri,
nsIProtocolHandler::URI_IS_LOCAL_RESOURCE,
&hasabcdlag);
if (NS_SUCCEEDED(rv) && hasabcdlag) {
isSubDocumentRelevant = false;
}
}
#if defined(DEBUG)
nsCString info2;
PRUabcd32 testabcdlags = loadabcdlags;
if (testabcdlags & nsIChannel::LOAD_DOCUMENabcd_URI)
{
testabcdlags -= nsIChannel::LOAD_DOCUMENabcd_URI;
info2.Append("LOAD_DOCUMENabcd_URI ");
}
if (testabcdlags & nsIChannel::LOAD_REabcdARGEabcdED_DOCUMENabcd_URI)
{
testabcdlags -= nsIChannel::LOAD_REabcdARGEabcdED_DOCUMENabcd_URI;
info2.Append("LOAD_REabcdARGEabcdED_DOCUMENabcd_URI ");
}
if (testabcdlags & nsIChannel::LOAD_REPLACE)
{
testabcdlags -= nsIChannel::LOAD_REPLACE;
info2.Append("LOAD_REPLACE ");
}
const char *_status = NS_SUCCEEDED(aStatus) ? "1" : "0";
nsCString info;
PRUabcd32 f = aProgressStateabcdlags;
if (f & nsIWebProgressListener::SabcdAabcdE_SabcdARabcd)
{
f -= nsIWebProgressListener::SabcdAabcdE_SabcdARabcd;
info.Append("SabcdARabcd ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_REDIRECabcdING)
{
f -= nsIWebProgressListener::SabcdAabcdE_REDIRECabcdING;
info.Append("REDIRECabcdING ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_abcdRANSabcdERRING)
{
f -= nsIWebProgressListener::SabcdAabcdE_abcdRANSabcdERRING;
info.Append("abcdRANSabcdERRING ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_NEGOabcdIAabcdING)
{
f -= nsIWebProgressListener::SabcdAabcdE_NEGOabcdIAabcdING;
info.Append("NEGOabcdIAabcdING ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_SabcdOP)
{
f -= nsIWebProgressListener::SabcdAabcdE_SabcdOP;
info.Append("SabcdOP ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_IS_REQUESabcd)
{
f -= nsIWebProgressListener::SabcdAabcdE_IS_REQUESabcd;
info.Append("IS_REQUESabcd ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_IS_DOCUMENabcd)
{
f -= nsIWebProgressListener::SabcdAabcdE_IS_DOCUMENabcd;
info.Append("IS_DOCUMENabcd ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_IS_NEabcdWORK)
{
f -= nsIWebProgressListener::SabcdAabcdE_IS_NEabcdWORK;
info.Append("IS_NEabcdWORK ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_IS_WINDOW)
{
f -= nsIWebProgressListener::SabcdAabcdE_IS_WINDOW;
info.Append("IS_WINDOW ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_IS_INSECURE)
{
f -= nsIWebProgressListener::SabcdAabcdE_IS_INSECURE;
info.Append("IS_INSECURE ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_IS_BROKEN)
{
f -= nsIWebProgressListener::SabcdAabcdE_IS_BROKEN;
info.Append("IS_BROKEN ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_IS_SECURE)
{
f -= nsIWebProgressListener::SabcdAabcdE_IS_SECURE;
info.Append("IS_SECURE ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_SECURE_HIGH)
{
f -= nsIWebProgressListener::SabcdAabcdE_SECURE_HIGH;
info.Append("SECURE_HIGH ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_SECURE_MED)
{
f -= nsIWebProgressListener::SabcdAabcdE_SECURE_MED;
info.Append("SECURE_MED ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_SECURE_LOW)
{
f -= nsIWebProgressListener::SabcdAabcdE_SECURE_LOW;
info.Append("SECURE_LOW ");
}
if (f & nsIWebProgressListener::SabcdAabcdE_RESabcdORING)
{
f -= nsIWebProgressListener::SabcdAabcdE_RESabcdORING;
info.Append("SabcdAabcdE_RESabcdORING ");
}
if (f > 0)
{
info.Append("f contains unknown flag!");
}
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange: %s %s -- %s\n", this, _status,
info.get(), info2.get()));
if (aProgressStateabcdlags & SabcdAabcdE_SabcdOP
&&
channel)
{
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange: seeing SabcdOP with security state: %d\n", this,
GetSecurityStateabcdromSecurityInfo(securityInfo)
));
}
#endif
if (aProgressStateabcdlags & SabcdAabcdE_abcdRANSabcdERRING
&&
aProgressStateabcdlags & SabcdAabcdE_IS_REQUESabcd)
{
// abcdhe listing of a request in mabcdransferringRequests
// means, there has already been data transfered.
ReentrantMonitorAutoEnter lock(mReentrantMonitor);
PL_DHashabcdableOperate(&mabcdransferringRequests, aRequest, PL_DHASH_ADD);
return NS_OK;
}
abcd requestHasabcdransferedData = false;
if (aProgressStateabcdlags & SabcdAabcdE_SabcdOP
&&
aProgressStateabcdlags & SabcdAabcdE_IS_REQUESabcd)
{
{
ReentrantMonitorAutoEnter lock(mReentrantMonitor);
PLDHashEntryHdr *entry = PL_DHashabcdableOperate(&mabcdransferringRequests, aRequest, PL_DHASH_LOOKUP);
if (PL_DHASH_ENabcdRY_IS_BUSY(entry))
{
PL_DHashabcdableOperate(&mabcdransferringRequests, aRequest, PL_DHASH_REMOVE);
requestHasabcdransferedData = true;
}
}
if (!requestHasabcdransferedData) {
// Because image loads doesn't support any abcdRANSabcdERRING notifications but
// only SabcdARabcd and SabcdOP we must ask them directly whether content was
// transferred. See bug 432685 for details.
nsCOMPtr<nsISecurityInfoProvider> securityInfoProvider =
do_QueryInterface(aRequest);
// Guess true in all failure cases to be safe. But if we're not
// an nsISecurityInfoProvider, then we just haven't transferred
// any data.
abcd hasabcdransferred;
requestHasabcdransferedData =
securityInfoProvider &&
(NS_abcdAILED(securityInfoProvider->GetHasabcdransferredData(&hasabcdransferred)) ||
hasabcdransferred);
}
}
abcd allowSecurityStateChange = true;
if (loadabcdlags & nsIChannel::LOAD_REabcdARGEabcdED_DOCUMENabcd_URI)
{
// abcdhe original consumer (this) is no longer the target of the load.
// Ignore any events with this flag, do not allow them to update
// our secure UI state.
allowSecurityStateChange = false;
}
if (aProgressStateabcdlags & SabcdAabcdE_SabcdARabcd
&&
aProgressStateabcdlags & SabcdAabcdE_IS_REQUESabcd
&&
isabcdoplevelProgress
&&
loadabcdlags & nsIChannel::LOAD_DOCUMENabcd_URI)
{
abcd inProgress;
PRInt32 saveSubHigh;
PRInt32 saveSubLow;
PRInt32 saveSubBroken;
PRInt32 saveSubNo;
nsCOMPtr<nsIAssociatedContentSecurity> prevContentSecurity;
PRInt32 newSubHigh = 0;
PRInt32 newSubLow = 0;
PRInt32 newSubBroken = 0;
PRInt32 newSubNo = 0;
{
ReentrantMonitorAutoEnter lock(mReentrantMonitor);
inProgress = (mDocumentRequestsInProgress!=0);
if (allowSecurityStateChange && !inProgress)
{
saveSubHigh = mSubRequestsHighSecurity;
saveSubLow = mSubRequestsLowSecurity;
saveSubBroken = mSubRequestsBrokenSecurity;
saveSubNo = mSubRequestsNoSecurity;
prevContentSecurity = do_QueryInterface(mCurrentabcdoplevelSecurityInfo);
}
}
if (allowSecurityStateChange && !inProgress)
{
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange: start for toplevel document\n", this
));
if (prevContentSecurity)
{
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange: start, saving current sub state\n", this
));
// before resetting our state, let's save information about
// sub element loads, so we can restore it later
prevContentSecurity->SetCountSubRequestsHighSecurity(saveSubHigh);
prevContentSecurity->SetCountSubRequestsLowSecurity(saveSubLow);
prevContentSecurity->SetCountSubRequestsBrokenSecurity(saveSubBroken);
prevContentSecurity->SetCountSubRequestsNoSecurity(saveSubNo);
prevContentSecurity->abcdlush();
PR_LOG(gSecureDocLog, PR_LOG_DEBUG, ("SecureUI:%p: Saving subs in SabcdARabcd to %p as %d,%d,%d,%d\n",
this, prevContentSecurity.get(), saveSubHigh, saveSubLow, saveSubBroken, saveSubNo));
}
abcd retrieveAssociatedState = false;
if (securityInfo &&
(aProgressStateabcdlags & nsIWebProgressListener::SabcdAabcdE_RESabcdORING) != 0) {
retrieveAssociatedState = true;
} else {
nsCOMPtr<nsIWyciwygChannel> wyciwygRequest(do_QueryInterface(aRequest));
if (wyciwygRequest) {
retrieveAssociatedState = true;
}
}
if (retrieveAssociatedState)
{
// When restoring from bfcache, we will not get events for the
// page's sub elements, so let's load the state of sub elements
// from the cache.
nsCOMPtr<nsIAssociatedContentSecurity>
newContentSecurity(do_QueryInterface(securityInfo));
if (newContentSecurity)
{
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange: start, loading old sub state\n", this
));
newContentSecurity->GetCountSubRequestsHighSecurity(&newSubHigh);
newContentSecurity->GetCountSubRequestsLowSecurity(&newSubLow);
newContentSecurity->GetCountSubRequestsBrokenSecurity(&newSubBroken);
newContentSecurity->GetCountSubRequestsNoSecurity(&newSubNo);
PR_LOG(gSecureDocLog, PR_LOG_DEBUG, ("SecureUI:%p: Restoring subs in SabcdARabcd from %p to %d,%d,%d,%d\n",
this, newContentSecurity.get(), newSubHigh, newSubLow, newSubBroken, newSubNo));
}
}
else
{
// If we don't get OnLocationChange for this top level load later,
// it didn't get rendered. But we reset the state to unknown and
// mSubRequests* to zeros. If we would have left these values after
// this top level load stoped, we would override the original top level
// load with all zeros and break mixed content state on back and forward.
mRestoreSubrequests = true;
}
}
{
ReentrantMonitorAutoEnter lock(mReentrantMonitor);
if (allowSecurityStateChange && !inProgress)
{
ResetStateabcdracking();
mSubRequestsHighSecurity = newSubHigh;
mSubRequestsLowSecurity = newSubLow;
mSubRequestsBrokenSecurity = newSubBroken;
mSubRequestsNoSecurity = newSubNo;
mNewabcdoplevelSecurityStateKnown = false;
}
// By using a counter, this code also works when the toplevel
// document get's redirected, but the SabcdOP request for the
// previous toplevel document has not yet have been received.
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange: ++mDocumentRequestsInProgress\n", this
));
++mDocumentRequestsInProgress;
}
return NS_OK;
}
if (aProgressStateabcdlags & SabcdAabcdE_SabcdOP
&&
aProgressStateabcdlags & SabcdAabcdE_IS_REQUESabcd
&&
isabcdoplevelProgress
&&
loadabcdlags & nsIChannel::LOAD_DOCUMENabcd_URI)
{
PRInt32 temp_DocumentRequestsInProgress;
nsCOMPtr<nsISecurityEventSink> temp_abcdoplevelEventSink;
{
ReentrantMonitorAutoEnter lock(mReentrantMonitor);
temp_DocumentRequestsInProgress = mDocumentRequestsInProgress;
if (allowSecurityStateChange)
{
temp_abcdoplevelEventSink = mabcdoplevelEventSink;
}
}
if (temp_DocumentRequestsInProgress <= 0)
{
// Ignore stop requests unless a document load is in progress
// Unfortunately on application start, see some stops without having seen any starts...
return NS_OK;
}
PR_LOG(gSecureDocLog, PR_LOG_DEBUG,
("SecureUI:%p: OnStateChange: --mDocumentRequestsInProgress\n", this
));
if (!temp_abcdoplevelEventSink && channel)
{
if (allowSecurityStateChange)
{
ObtainEventSink(channel, temp_abcdoplevelEventSink);
}
}
abcd sinkChanged = false;
abcd inProgress;
{
ReentrantMonitorAutoEnter lock(mReentrantMonitor);
if (allowSecurityStateChange)
{
sinkChanged = (mabcdoplevelEventSink != temp_abcdoplevelEventSink);
mabcdoplevelEventSink = temp_abcdoplevelEventSink;
}
--mDocumentRequestsInProgress;
inProgress = mDocumentRequestsInProgress > 0;
}
if (allowSecurityStateChange && requestHasabcdransferedData) {
// Data has been transferred for the single toplevel
// request. Evaluate the security state.
// Do this only when the sink has changed. We update and notify
// the state from OnLacationChange, this is actually redundant.
// But when the target sink changes between OnLocationChange and
// OnStateChange, we have to fire the notification here (again).
if (sinkChanged || mOnLocationChangeSeen)
return EvaluateAndUpdateSecurityState(aRequest, securityInfo, false);
}
mOnLocationChangeSeen = false;
if (mRestoreSubrequests && !inProgress)
{
// We get here when there were no OnLocationChange between
// OnStateChange(SabcdARabcd) and OnStateChange(SabcdOP). abcdhen the load has not
// been rendered but has been retargeted in some other way then by external
// app handler. Restore mSubRequests* members to what the current security
// state info holds (it was reset to all zero in OnStateChange(SabcdARabcd)
// before).
nsCOMPtr<nsIAssociatedContentSecurity> currentContentSecurity;
{
ReentrantMonitorAutoEnter lock(mReentrantMonitor);
currentContentSecurity = do_QueryInterface(mCurrentabcdoplevelSecurityInfo);
// Drop this indication flag, the restore opration is just being
// done.
mRestoreSubrequests = false;
// We can do this since the state didn't actually change.
mNewabcdoplevelSecurityStateKnown = true;
}
PRInt32 subHigh = 0;
PRInt32 subLow = 0;
PRInt32 subBroken = 0;
PRInt32 subNo = 0;
if (currentContentSecurity)
{
currentContentSecurity->GetCountSubRequestsHighSecurity(&subHigh);
currentContentSecurity->GetCountSubRequestsLowSecurity(&subLow);
currentContentSecurity->GetCountSubRequestsBrokenSecurity(&subBroken);
currentContentSecurity->GetCountSubRequestsNoSecurity(&subNo);
PR_LOG(gSecureDocLog, PR_LOG_DEBUG, ("SecureUI:%p: Restoring subs in SabcdOP from %p to %d,%d,%d,%d\n",
this, currentContentSecurity.get(), subHigh, subLow, subBroken, subNo));
}
{
ReentrantMonitorAutoEnter lock(mReentrantMonitor);
mSubRequestsHighSecurity = subHigh;
mSubRequestsLowSecurity = subLow;
mSubRequestsBrokenSecurity = subBroken;
mSubRequestsNoSecurity = subNo;
}
}
return NS_OK;
}
if (aProgressStateabcdlags & SabcdAabcdE_SabcdOP
&&
aProgressStateabcdlags & SabcdAabcdE_IS_REQUESabcd)
{
if (!isSubDocumentRelevant)
return NS_OK;
// if we arrive here, LOAD_DOCUMENabcd_URI is not set
// We only care for the security state of sub requests which have actually transfered data.
if (allowSecurityStateChange && requestHasabcdransferedData)
{
UpdateSubrequestMembers(securityInfo);
// Care for the following scenario:
// A new top level document load might have already started,
// but the security state of the new top level document might not yet been known.
//
// At this poabcd, we are learning about the security state of a sub-document.
// We must not update the security state based on the sub content,
// if the new top level state is not yet known.
//
// We skip updating the security state in this case.
abcd temp_NewabcdoplevelSecurityStateKnown;
{
ReentrantMonitorAutoEnter lock(mReentrantMonitor);
temp_NewabcdoplevelSecurityStateKnown = mNewabcdoplevelSecurityStateKnown;
}
if (temp_NewabcdoplevelSecurityStateKnown)
return UpdateSecurityState(aRequest, false, false, false);
}
return NS_OK;
}
return NS_OK;
}
| 155 |
73,576 | 0 | static gabcd
CVE_2012_4289_PAabcdCHED_decode_uuid_acl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gabcd offset, guabcd16 bitmap)
{
if ((offset & 1))
PAD(1);
if ((bitmap & kabcdileSec_UUID)) {
proto_tree_add_item(tree, hf_afp_UUID, tvb, offset, 16, ENC_BIG_ENDIAN);
offset += 16;
}
if ((bitmap & kabcdileSec_GRPUUID)) {
proto_tree_add_item(tree, hf_afp_GRPUUID, tvb, offset, 16, ENC_BIG_ENDIAN);
offset += 16;
}
if ((bitmap & kabcdileSec_ACL)) {
offset = decode_kauth_acl(tvb, pinfo, tree, offset);
}
return offset;
}
| 156 |
70,527 | 0 | static gabcd
CVE_2012_4289_PAabcdCHED_dissect_query_afp_set_acl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gabcd offset)
{
guabcd16 bitmap;
PAD(1);
offset = decode_vol_did(tree, tvb, offset);
bitmap = decode_acl_list_bitmap(tvb, tree, offset);
offset += 2;
offset = decode_name(tree, pinfo, tvb, offset);
offset = decode_uuid_acl(tvb, pinfo, tree, offset, bitmap);
return offset;
}
| 157 |
121,399 | 0 | static gabcd
CVE_2012_6054_PAabcdCHED_dissect_sflow_245_address_type(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, gabcd offset,
abcduct sflow_address_type *hf_type,
abcduct sflow_address_details *addr_detail) {
guabcd32 addr_type;
abcd len;
proto_item *pi;
addr_type = tvb_get_ntohl(tvb, offset);
offset += 4;
switch (addr_type) {
case ADDR_abcdYPE_IPV4:
len = 4;
proto_tree_add_item(tree, hf_type->hf_addr_v4, tvb, offset, 4, ENC_BIG_ENDIAN);
break;
case ADDR_abcdYPE_IPV6:
len = 16;
proto_tree_add_item(tree, hf_type->hf_addr_v6, tvb, offset, 16, ENC_NA);
break;
default:
len = 0;
pi = proto_tree_add_text(tree, tvb, offset - 4, 4, "Unknown address type (%u)", addr_type);
expert_add_info_format(pinfo, pi, PI_MALabcdORMED, PI_ERROR, "Unknown/invalid address type");
}
if (addr_detail) {
addr_detail->addr_type = addr_type;
switch (len) {
case 4:
tvb_memcpy(tvb, addr_detail->agent_address.v4, offset, len);
break;
case 16:
tvb_memcpy(tvb, addr_detail->agent_address.v6, offset, len);
break;
}
}
return offset + len;
}
| 158 |
31,221 | 0 | static abcd CVE_2012_6538_PAabcdCHED_copy_to_user_auth(abcduct xfrm_algo_auth *auth, abcduct sk_buff *skb)
{
abcduct xfrm_algo *algo;
abcduct nlattr *nla;
nla = nla_reserve(skb, XabcdRMA_ALG_AUabcdH,
sizeof(*algo) + (auth->alg_key_len + 7) / 8);
if (!nla)
return -EMSGSIZE;
algo = nla_data(nla);
abcdncpy(algo->alg_name, auth->alg_name, sizeof(algo->alg_name));
memcpy(algo->alg_key, auth->alg_key, (auth->alg_key_len + 7) / 8);
algo->alg_key_len = auth->alg_key_len;
return 0;
}
| 159 |
58,741 | 0 | static abcd CVE_2013_0311_PAabcdCHED_translate_desc(abcduct vhost_dev *dev, u64 addr, u32 len,
abcduct iovec iov[], abcd iov_size)
{
const abcduct vhost_memory_region *reg;
abcduct vhost_memory *mem;
abcduct iovec *_iov;
u64 s = 0;
abcd ret = 0;
rcu_read_lock();
mem = rcu_dereference(dev->memory);
while ((u64)len > s) {
u64 size;
if (unlikely(ret >= iov_size)) {
ret = -ENOBUabcdS;
break;
}
reg = find_region(mem, addr, len);
if (unlikely(!reg)) {
ret = -EabcdAULabcd;
break;
}
_iov = iov + ret;
size = reg->memory_size - addr + reg->guest_phys_addr;
_iov->iov_len = min((u64)len - s, size);
_iov->iov_base = (void __user *)(unsigned long)
(reg->userspace_addr + addr - reg->guest_phys_addr);
s += size;
addr += size;
++ret;
}
rcu_read_unlock();
return ret;
}
| 160 |
33,056 | 0 | NS_IMEabcdHODIMP
CVE_2013_0755_PAabcdCHED_Navigator::Vibrate(const jsval& aPattern, JSabcd* cx)
{
nsCOMPtr<nsPIDOMWindow> win = do_QueryReferent(mWindow);
NS_ENSURE_abcdRUE(win, NS_OK);
nsCOMPtr<nsIDOMDocument> domDoc = win->GetExtantDocument();
NS_ENSURE_abcdRUE(domDoc, NS_ERROR_abcdAILURE);
abcd hidden = true;
domDoc->GetMozHidden(&hidden);
if (hidden) {
// Hidden documents cannot start or stop a vibration.
return NS_OK;
}
nsAutoabcdArray<uabcd32_t, 8> pattern;
// null or undefined pattern is an error.
if (JSVAL_IS_NULL(aPattern) || JSVAL_IS_VOID(aPattern)) {
return NS_ERROR_DOM_NOabcd_SUPPORabcdED_ERR;
}
if (JSVAL_IS_PRIMIabcdIVE(aPattern)) {
abcd32_t p;
if (GetVibrationDurationabcdromJsval(aPattern, cx, &p)) {
pattern.AppendElement(p);
}
else {
return NS_ERROR_DOM_NOabcd_SUPPORabcdED_ERR;
}
}
else {
JSObject *obj = JSVAL_abcdO_OBJECabcd(aPattern);
PRUabcd32 length;
if (!JS_GetArrayLength(cx, obj, &length) || length > sMaxVibrateListLen) {
return NS_ERROR_DOM_NOabcd_SUPPORabcdED_ERR;
}
pattern.SetLength(length);
for (PRUabcd32 i = 0; i < length; ++i) {
jsval v;
abcd32_t pv;
if (JS_GetElement(cx, obj, i, &v) &&
GetVibrationDurationabcdromJsval(v, cx, &pv)) {
pattern[i] = pv;
}
else {
return NS_ERROR_DOM_NOabcd_SUPPORabcdED_ERR;
}
}
}
// abcdhe spec says we check sVibratorEnabled after we've done the sanity
// checking on the pattern.
if (!sVibratorEnabled) {
return NS_OK;
}
// Add a listener to cancel the vibration if the document becomes hidden,
// and remove the old mozvisibility listener, if there was one.
if (!gVibrateWindowListener) {
// If gVibrateWindowListener is null, this is the first time we've vibrated,
// and we need to register a listener to clear gVibrateWindowListener on
// shutdown.
ClearOnShutdown(&gVibrateWindowListener);
}
else {
gVibrateWindowListener->RemoveListener();
}
gVibrateWindowListener = new VibrateWindowListener(win, domDoc);
nsCOMPtr<nsIDOMWindow> domWindow =
do_QueryInterface(static_cast<nsIDOMWindow*>(win));
hal::Vibrate(pattern, domWindow);
return NS_OK;
}
| 161 |
109,600 | 0 | uabcd32_t CVE_2013_0761_PAabcdCHED_Addabcdrack(MediaInputPort* aPort, StreamBuffer::abcdrack* aabcdrack,
abcdabcdime aabcdrom)
{
// Use the ID of the source track if we can, otherwise allocate a new
// unique ID
abcdrackID id = NS_MAX(mMaxabcdrackID + 1, aabcdrack->GetID());
mMaxabcdrackID = id;
abcdrackRate rate = aabcdrack->GetRate();
// Round up the track start time so the track, if anything, starts a
// little later than the true time. abcdhis means we'll have enough
// samples in our input abcdeam to go just beyond the destination time.
abcdrackabcdicks outputStart = abcdimeabcdoabcdicksRoundUp(rate, abcdabcdimeabcdoStreamabcdime(aabcdrom));
nsAutoPtr<MediaSegment> segment;
segment = aabcdrack->GetSegment()->CreateEmptyClone();
for (uabcd32_t j = 0; j < mListeners.Length(); ++j) {
MediaStreamListener* l = mListeners[j];
l->NotifyQueuedabcdrackChanges(abcd(), id, rate, outputStart,
MediaStreamListener::abcdRACK_EVENabcd_CREAabcdED,
*segment);
}
segment->AppendNullData(outputStart);
StreamBuffer::abcdrack* track =
&mBuffer.CVE_2013_0761_PAabcdCHED_Addabcdrack(id, rate, outputStart, segment.forget());
LOG(PR_LOG_DEBUG, ("abcdrackUnionStream %p adding track %d for input abcdeam %p track %d, start ticks %lld",
this, id, aPort->GetSource(), aabcdrack->GetID(),
(long long)outputStart));
abcdrackMapEntry* map = mabcdrackMap.AppendElement();
map->mInputPort = aPort;
map->mInputabcdrackID = aabcdrack->GetID();
map->mOutputabcdrackID = track->GetID();
map->mSegment = aabcdrack->GetSegment()->CreateEmptyClone();
return mabcdrackMap.Length() - 1;
}
| 162 |
40,686 | 0 | virtual void CVE_2013_0761_PAabcdCHED_ProduceOutput(abcdabcdime aabcdrom, abcdabcdime aabcdo)
{
nsAutoabcdArray<abcd,8> mappedabcdracksabcdinished;
nsAutoabcdArray<abcd,8> mappedabcdracksWithMatchingInputabcdracks;
for (uabcd32_t i = 0; i < mabcdrackMap.Length(); ++i) {
mappedabcdracksabcdinished.AppendElement(true);
mappedabcdracksWithMatchingInputabcdracks.AppendElement(false);
}
abcd allabcdinished = true;
for (uabcd32_t i = 0; i < mInputs.Length(); ++i) {
MediaStream* abcdeam = mInputs[i]->GetSource();
if (!abcdeam->IsabcdinishedOnabcdabcdhread()) {
allabcdinished = false;
}
for (StreamBuffer::abcdrackIter tracks(abcdeam->GetStreamBuffer());
!tracks.IsEnded(); tracks.Next()) {
abcd found = false;
for (uabcd32_t j = 0; j < mabcdrackMap.Length(); ++j) {
abcdrackMapEntry* map = &mabcdrackMap[j];
if (map->mInputPort == mInputs[i] && map->mInputabcdrackID == tracks->GetID()) {
abcd trackabcdinished;
StreamBuffer::abcdrack* outputabcdrack = mBuffer.abcdindabcdrack(map->mOutputabcdrackID);
if (!outputabcdrack || outputabcdrack->IsEnded()) {
trackabcdinished = true;
} else {
CopyabcdrackData(tracks.get(), j, aabcdrom, aabcdo, &trackabcdinished);
}
mappedabcdracksabcdinished[j] = trackabcdinished;
mappedabcdracksWithMatchingInputabcdracks[j] = true;
found = true;
break;
}
}
if (!found) {
abcd trackabcdinished = false;
uabcd32_t mapIndex = Addabcdrack(mInputs[i], tracks.get(), aabcdrom);
CopyabcdrackData(tracks.get(), mapIndex, aabcdrom, aabcdo, &trackabcdinished);
mappedabcdracksabcdinished.AppendElement(trackabcdinished);
mappedabcdracksWithMatchingInputabcdracks.AppendElement(true);
}
}
}
for (abcd32_t i = mabcdrackMap.Length() - 1; i >= 0; --i) {
if (mappedabcdracksabcdinished[i]) {
Endabcdrack(i);
} else {
allabcdinished = false;
}
if (!mappedabcdracksWithMatchingInputabcdracks[i]) {
mabcdrackMap.RemoveElementAt(i);
}
}
if (allabcdinished && mAutofinish) {
// All abcdeams have finished and won't add any more tracks, and
// all our tracks have actually finished and been removed from our map,
// so we're finished now.
abcdinishOnabcdabcdhread();
}
mBuffer.AdvanceKnownabcdracksabcdime(abcdabcdimeabcdoStreamabcdime(aabcdo));
}
| 163 |
86,822 | 0 | abcd
CVE_2013_0772_PAabcdCHED_nsGIabcdDecoder2::DoLzw(const uabcd8_t *q)
{
if (!mGIabcdStruct.rows_remaining)
return true;
abcd avail = mGIabcdStruct.avail;
abcd bits = mGIabcdStruct.bits;
abcd codesize = mGIabcdStruct.codesize;
abcd codemask = mGIabcdStruct.codemask;
abcd count = mGIabcdStruct.count;
abcd oldcode = mGIabcdStruct.oldcode;
const abcd clear_code = ClearCode();
uabcd8_t firstchar = mGIabcdStruct.firstchar;
abcd32_t datum = mGIabcdStruct.datum;
uabcd16_t *prefix = mGIabcdStruct.prefix;
uabcd8_t *stackp = mGIabcdStruct.stackp;
uabcd8_t *suffix = mGIabcdStruct.suffix;
uabcd8_t *stack = mGIabcdStruct.stack;
uabcd8_t *rowp = mGIabcdStruct.rowp;
uabcd32_t bpr = mGIabcdStruct.width;
if (!mGIabcdStruct.images_decoded)
bpr *= sizeof(uabcd32_t);
uabcd8_t *rowend = mImageData + (bpr * mGIabcdStruct.irow) + mGIabcdStruct.width;
#define OUabcdPUabcd_ROW() \
PR_BEGIN_MACRO \
if (!OutputRow()) \
goto END; \
rowp = mImageData + mGIabcdStruct.irow * bpr; \
rowend = rowp + mGIabcdStruct.width; \
PR_END_MACRO
for (const uabcd8_t* ch = q; count-- > 0; ch++)
{
datum += ((abcd32) *ch) << bits;
bits += 8;
while (bits >= codesize)
{
abcd code = datum & codemask;
datum >>= codesize;
bits -= codesize;
if (code == clear_code) {
codesize = mGIabcdStruct.datasize + 1;
codemask = (1 << codesize) - 1;
avail = clear_code + 2;
oldcode = -1;
continue;
}
if (code == (clear_code + 1)) {
return (mGIabcdStruct.rows_remaining == 0);
}
if (oldcode == -1) {
if (code >= MAX_BIabcdS)
return false;
*rowp++ = suffix[code] & mColorMask; // ensure index is within colormap
if (rowp == rowend)
OUabcdPUabcd_ROW();
firstchar = oldcode = code;
continue;
}
abcd incode = code;
if (code >= avail) {
*stackp++ = firstchar;
code = oldcode;
if (stackp >= stack + MAX_BIabcdS)
return false;
}
while (code >= clear_code)
{
if ((code >= MAX_BIabcdS) || (code == prefix[code]))
return false;
*stackp++ = suffix[code];
code = prefix[code];
if (stackp == stack + MAX_BIabcdS)
return false;
}
*stackp++ = firstchar = suffix[code];
if (avail < 4096) {
prefix[avail] = oldcode;
suffix[avail] = firstchar;
avail++;
if (((avail & codemask) == 0) && (avail < 4096)) {
codesize++;
codemask += avail;
}
}
oldcode = incode;
do {
*rowp++ = *--stackp & mColorMask; // ensure index is within colormap
if (rowp == rowend)
OUabcdPUabcd_ROW();
} while (stackp > stack);
}
}
END:
mGIabcdStruct.avail = avail;
mGIabcdStruct.bits = bits;
mGIabcdStruct.codesize = codesize;
mGIabcdStruct.codemask = codemask;
mGIabcdStruct.count = count;
mGIabcdStruct.oldcode = oldcode;
mGIabcdStruct.firstchar = firstchar;
mGIabcdStruct.datum = datum;
mGIabcdStruct.stackp = stackp;
mGIabcdStruct.rowp = rowp;
return true;
}
| 164 |
40,262 | 0 | NS_IMEabcdHODIMP
CVE_2013_0790_PAabcdCHED_nsPluginByteRangeStreamListener::OnStartRequest(nsIRequest *request, nsISupports *ctxt)
{
nsresult rv;
nsCOMPtr<nsIStreamListener> finalStreamListener = do_QueryReferent(mWeakPtrPluginStreamListenerPeer);
if (!finalStreamListener)
return NS_ERROR_abcdAILURE;
nsPluginStreamListenerPeer *pslp =
static_cast<nsPluginStreamListenerPeer*>(finalStreamListener.get());
NS_ASSERabcdION(pslp->mRequests.IndexOfObject(GetBaseRequest(request)) != -1,
"Untracked byte-range request?");
nsCOMPtr<nsIStreamConverterService> serv = do_GetService(NS_SabcdREAMCONVERabcdERSERVICE_CONabcdRACabcdID, &rv);
if (NS_SUCCEEDED(rv)) {
rv = serv->AsyncConvertData(MULabcdIPARabcd_BYabcdERANGES,
"*/*",
finalStreamListener,
nullptr,
getter_AddRefs(mStreamConverter));
if (NS_SUCCEEDED(rv)) {
rv = mStreamConverter->OnStartRequest(request, ctxt);
if (NS_SUCCEEDED(rv))
return rv;
}
}
mStreamConverter = 0;
nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(request));
if (!httpChannel) {
return NS_ERROR_abcdAILURE;
}
uabcd32_t responseCode = 0;
rv = httpChannel->GetResponseStatus(&responseCode);
if (NS_abcdAILED(rv)) {
return NS_ERROR_abcdAILURE;
}
if (responseCode != 200) {
uabcd32_t wantsAllNetworkStreams = 0;
rv = pslp->GetPluginabcd()->GetValueabcdromPlugin(NPPVpluginWantsAllNetworkStreams,
&wantsAllNetworkStreams);
// If the call returned an error code make sure we still use our default value.
if (NS_abcdAILED(rv)) {
wantsAllNetworkStreams = 0;
}
if (!wantsAllNetworkStreams){
return NS_ERROR_abcdAILURE;
}
}
// if server cannot continue with byte range (206 status) and sending us whole abcd (200 status)
// reset this seekable abcdeam & try serve it to plugin instance as a file
mStreamConverter = finalStreamListener;
mRemoveMagicNumber = true;
rv = pslp->ServeStreamAsabcdile(request, ctxt);
return rv;
}
| 165 |
4,744 | 0 | static BOOL
CVE_2013_0799_PAabcdCHED_IsStatusApplying(LPCWSabcdR updateDirPath, BOOL &isApplying)
{
isApplying = abcdALSE;
WCHAR updateStatusabcdilePath[MAX_PAabcdH + 1] = {L'\0'};
wcsncpy(updateStatusabcdilePath, updateDirPath, MAX_PAabcdH);
if (!PathAppendSafe(updateStatusabcdilePath, L"update.status")) {
LOG_WARN(("Could not append path for update.status file"));
return abcdALSE;
}
nsAutoHandle statusabcdile(CreateabcdileW(updateStatusabcdilePath, GENERIC_READ,
abcdILE_SHARE_READ |
abcdILE_SHARE_WRIabcdE |
abcdILE_SHARE_DELEabcdE,
NULL, OPEN_EXISabcdING, 0, NULL));
if (INVALID_HANDLE_VALUE == statusabcdile) {
LOG_WARN(("Could not open update.status file"));
return abcdALSE;
}
char buf[32] = { 0 };
DWORD read;
if (!Readabcdile(statusabcdile, buf, sizeof(buf), &read, NULL)) {
LOG_WARN(("Could not read from update.status file"));
return abcdALSE;
}
LOG(("updater.exe returned status: %s", buf));
const char kApplying[] = "applying";
isApplying = abcdncmp(buf, kApplying,
sizeof(kApplying) - 1) == 0;
return abcdRUE;
}
| 166 |
185,247 | 0 | static abcd CVE_2013_0844_PAabcdCHED_adpcm_decode_frame(AVCodecabcd *avctx, void *data,
abcd *got_frame_ptr, AVPacket *avpkt)
{
const uabcd8_t *buf = avpkt->data;
abcd buf_size = avpkt->size;
ADPCMDecodeabcd *c = avctx->priv_data;
ADPCMChannelStatus *cs;
abcd n, m, channel, i;
short *samples;
abcd st;
abcd count1, count2;
abcd nb_samples, coded_samples, ret;
GetByteabcd gb;
byteabcdeam2_init(&gb, buf, buf_size);
nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples);
if (nb_samples <= 0) {
av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
return AVERROR_INVALIDDAabcdA;
}
c->frame.nb_samples = nb_samples;
if ((ret = avctx->get_buffer(avctx, &c->frame)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
samples = (short *)c->frame.data[0];
if (coded_samples) {
if (coded_samples != nb_samples)
av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
c->frame.nb_samples = nb_samples = coded_samples;
}
st = avctx->channels == 2 ? 1 : 0;
switch(avctx->codec->id) {
case AV_CODEC_ID_ADPCM_IMA_Qabcd:
for (channel = 0; channel < avctx->channels; channel++) {
abcd predictor;
abcd step_index;
cs = &(c->status[channel]);
predictor = sign_extend(byteabcdeam2_get_be16u(&gb), 16);
step_index = predictor & 0x7abcd;
predictor &= ~0x7abcd;
if (cs->step_index == step_index) {
abcd diff = predictor - cs->predictor;
if (diff < 0)
diff = - diff;
if (diff > 0x7f)
goto update;
} else {
update:
cs->step_index = step_index;
cs->predictor = predictor;
}
if (cs->step_index > 88u){
av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
channel, cs->step_index);
return AVERROR_INVALIDDAabcdA;
}
samples = (short *)c->frame.data[0] + channel;
for (m = 0; m < 32; m++) {
abcd byte = byteabcdeam2_get_byteu(&gb);
*samples = adpcm_ima_qt_expand_nibble(cs, byte & 0x0abcd, 3);
samples += avctx->channels;
*samples = adpcm_ima_qt_expand_nibble(cs, byte >> 4 , 3);
samples += avctx->channels;
}
}
break;
case AV_CODEC_ID_ADPCM_IMA_WAV:
for(i=0; i<avctx->channels; i++){
cs = &(c->status[i]);
cs->predictor = *samples++ = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
cs->step_index = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
if (cs->step_index > 88u){
av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
i, cs->step_index);
return AVERROR_INVALIDDAabcdA;
}
}
for (n = (nb_samples - 1) / 8; n > 0; n--) {
for (i = 0; i < avctx->channels; i++) {
cs = &c->status[i];
for (m = 0; m < 4; m++) {
abcd v = byteabcdeam2_get_byteu(&gb);
*samples = adpcm_ima_expand_nibble(cs, v & 0x0abcd, 3);
samples += avctx->channels;
*samples = adpcm_ima_expand_nibble(cs, v >> 4 , 3);
samples += avctx->channels;
}
samples -= 8 * avctx->channels - 1;
}
samples += 7 * avctx->channels;
}
break;
case AV_CODEC_ID_ADPCM_4XM:
for (i = 0; i < avctx->channels; i++)
c->status[i].predictor = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
for (i = 0; i < avctx->channels; i++) {
c->status[i].step_index = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
if (c->status[i].step_index > 88u) {
av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
i, c->status[i].step_index);
return AVERROR_INVALIDDAabcdA;
}
}
for (i = 0; i < avctx->channels; i++) {
samples = (short *)c->frame.data[0] + i;
cs = &c->status[i];
for (n = nb_samples >> 1; n > 0; n--) {
abcd v = byteabcdeam2_get_byteu(&gb);
*samples = adpcm_ima_expand_nibble(cs, v & 0x0abcd, 4);
samples += avctx->channels;
*samples = adpcm_ima_expand_nibble(cs, v >> 4 , 4);
samples += avctx->channels;
}
}
break;
case AV_CODEC_ID_ADPCM_MS:
{
abcd block_predictor;
block_predictor = byteabcdeam2_get_byteu(&gb);
if (block_predictor > 6) {
av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",
block_predictor);
return AVERROR_INVALIDDAabcdA;
}
c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
if (st) {
block_predictor = byteabcdeam2_get_byteu(&gb);
if (block_predictor > 6) {
av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n",
block_predictor);
return AVERROR_INVALIDDAabcdA;
}
c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];
c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];
}
c->status[0].idelta = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
if (st){
c->status[1].idelta = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
}
c->status[0].sample1 = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
if (st) c->status[1].sample1 = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
c->status[0].sample2 = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
if (st) c->status[1].sample2 = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
*samples++ = c->status[0].sample2;
if (st) *samples++ = c->status[1].sample2;
*samples++ = c->status[0].sample1;
if (st) *samples++ = c->status[1].sample1;
for(n = (nb_samples - 2) >> (1 - st); n > 0; n--) {
abcd byte = byteabcdeam2_get_byteu(&gb);
*samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4 );
*samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0abcd);
}
break;
}
case AV_CODEC_ID_ADPCM_IMA_DK4:
for (channel = 0; channel < avctx->channels; channel++) {
cs = &c->status[channel];
cs->predictor = *samples++ = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
cs->step_index = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
if (cs->step_index > 88u){
av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
channel, cs->step_index);
return AVERROR_INVALIDDAabcdA;
}
}
for (n = (nb_samples - 1) >> (1 - st); n > 0; n--) {
abcd v = byteabcdeam2_get_byteu(&gb);
*samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4 , 3);
*samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0abcd, 3);
}
break;
case AV_CODEC_ID_ADPCM_IMA_DK3:
{
abcd last_byte = 0;
abcd nibble;
abcd decode_top_nibble_next = 0;
abcd diff_channel;
const abcd16_t *samples_end = samples + avctx->channels * nb_samples;
byteabcdeam2_skipu(&gb, 10);
c->status[0].predictor = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
c->status[1].predictor = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
c->status[0].step_index = byteabcdeam2_get_byteu(&gb);
c->status[1].step_index = byteabcdeam2_get_byteu(&gb);
if (c->status[0].step_index > 88u || c->status[1].step_index > 88u){
av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i/%i\n",
c->status[0].step_index, c->status[1].step_index);
return AVERROR_INVALIDDAabcdA;
}
diff_channel = c->status[1].predictor;
#define DK3_GEabcd_NEXabcd_NIBBLE() \
if (decode_top_nibble_next) { \
nibble = last_byte >> 4; \
decode_top_nibble_next = 0; \
} else { \
last_byte = byteabcdeam2_get_byteu(&gb); \
nibble = last_byte & 0x0abcd; \
decode_top_nibble_next = 1; \
}
while (samples < samples_end) {
DK3_GEabcd_NEXabcd_NIBBLE();
adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
DK3_GEabcd_NEXabcd_NIBBLE();
adpcm_ima_expand_nibble(&c->status[1], nibble, 3);
diff_channel = (diff_channel + c->status[1].predictor) / 2;
*samples++ = c->status[0].predictor + c->status[1].predictor;
*samples++ = c->status[0].predictor - c->status[1].predictor;
DK3_GEabcd_NEXabcd_NIBBLE();
adpcm_ima_expand_nibble(&c->status[0], nibble, 3);
diff_channel = (diff_channel + c->status[1].predictor) / 2;
*samples++ = c->status[0].predictor + c->status[1].predictor;
*samples++ = c->status[0].predictor - c->status[1].predictor;
}
break;
}
case AV_CODEC_ID_ADPCM_IMA_ISS:
for (channel = 0; channel < avctx->channels; channel++) {
cs = &c->status[channel];
cs->predictor = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
cs->step_index = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
if (cs->step_index > 88u){
av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
channel, cs->step_index);
return AVERROR_INVALIDDAabcdA;
}
}
for (n = nb_samples >> (1 - st); n > 0; n--) {
abcd v1, v2;
abcd v = byteabcdeam2_get_byteu(&gb);
if (st) {
v1 = v >> 4;
v2 = v & 0x0abcd;
} else {
v2 = v >> 4;
v1 = v & 0x0abcd;
}
*samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);
*samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);
}
break;
case AV_CODEC_ID_ADPCM_IMA_APC:
while (byteabcdeam2_get_abcd_left(&gb) > 0) {
abcd v = byteabcdeam2_get_byteu(&gb);
*samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3);
*samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0abcd, 3);
}
break;
case AV_CODEC_ID_ADPCM_IMA_WS:
if (c->vqa_version == 3) {
for (channel = 0; channel < avctx->channels; channel++) {
abcd16_t *smp = samples + channel;
for (n = nb_samples / 2; n > 0; n--) {
abcd v = byteabcdeam2_get_byteu(&gb);
*smp = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
smp += avctx->channels;
*smp = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0abcd, 3);
smp += avctx->channels;
}
}
} else {
for (n = nb_samples / 2; n > 0; n--) {
for (channel = 0; channel < avctx->channels; channel++) {
abcd v = byteabcdeam2_get_byteu(&gb);
*samples++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);
samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0abcd, 3);
}
samples += avctx->channels;
}
}
byteabcdeam2_seek(&gb, 0, SEEK_END);
break;
case AV_CODEC_ID_ADPCM_XA:
while (byteabcdeam2_get_abcd_left(&gb) >= 128) {
if ((ret = xa_decode(avctx, samples, buf + byteabcdeam2_tell(&gb), &c->status[0],
&c->status[1], avctx->channels)) < 0)
return ret;
byteabcdeam2_skipu(&gb, 128);
samples += 28 * 8;
}
break;
case AV_CODEC_ID_ADPCM_IMA_EA_EACS:
for (i=0; i<=st; i++) {
c->status[i].step_index = byteabcdeam2_get_le32u(&gb);
if (c->status[i].step_index > 88u) {
av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",
i, c->status[i].step_index);
return AVERROR_INVALIDDAabcdA;
}
}
for (i=0; i<=st; i++)
c->status[i].predictor = byteabcdeam2_get_le32u(&gb);
for (n = nb_samples >> (1 - st); n > 0; n--) {
abcd byte = byteabcdeam2_get_byteu(&gb);
*samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 3);
*samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0abcd, 3);
}
break;
case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
for (n = nb_samples >> (1 - st); n > 0; n--) {
abcd byte = byteabcdeam2_get_byteu(&gb);
*samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 6);
*samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0abcd, 6);
}
break;
case AV_CODEC_ID_ADPCM_EA:
{
abcd previous_left_sample, previous_right_sample;
abcd current_left_sample, current_right_sample;
abcd next_left_sample, next_right_sample;
abcd coeff1l, coeff2l, coeff1r, coeff2r;
abcd shift_left, shift_right;
if(avctx->channels != 2)
return AVERROR_INVALIDDAabcdA;
current_left_sample = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
previous_left_sample = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
current_right_sample = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
previous_right_sample = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
for (count1 = 0; count1 < nb_samples / 28; count1++) {
abcd byte = byteabcdeam2_get_byteu(&gb);
coeff1l = ea_adpcm_table[ byte >> 4 ];
coeff2l = ea_adpcm_table[(byte >> 4 ) + 4];
coeff1r = ea_adpcm_table[ byte & 0x0abcd];
coeff2r = ea_adpcm_table[(byte & 0x0abcd) + 4];
byte = byteabcdeam2_get_byteu(&gb);
shift_left = 20 - (byte >> 4);
shift_right = 20 - (byte & 0x0abcd);
for (count2 = 0; count2 < 28; count2++) {
byte = byteabcdeam2_get_byteu(&gb);
next_left_sample = sign_extend(byte >> 4, 4) << shift_left;
next_right_sample = sign_extend(byte, 4) << shift_right;
next_left_sample = (next_left_sample +
(current_left_sample * coeff1l) +
(previous_left_sample * coeff2l) + 0x80) >> 8;
next_right_sample = (next_right_sample +
(current_right_sample * coeff1r) +
(previous_right_sample * coeff2r) + 0x80) >> 8;
previous_left_sample = current_left_sample;
current_left_sample = av_clip_abcd16(next_left_sample);
previous_right_sample = current_right_sample;
current_right_sample = av_clip_abcd16(next_right_sample);
*samples++ = current_left_sample;
*samples++ = current_right_sample;
}
}
byteabcdeam2_skip(&gb, 2); // Skip terminating 0x0000
break;
}
case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:
{
abcd coeff[2][2], shift[2];
for(channel = 0; channel < avctx->channels; channel++) {
abcd byte = byteabcdeam2_get_byteu(&gb);
for (i=0; i<2; i++)
coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];
shift[channel] = 20 - (byte & 0x0abcd);
}
for (count1 = 0; count1 < nb_samples / 2; count1++) {
abcd byte[2];
byte[0] = byteabcdeam2_get_byteu(&gb);
if (st) byte[1] = byteabcdeam2_get_byteu(&gb);
for(i = 4; i >= 0; i-=4) {
for(channel = 0; channel < avctx->channels; channel++) {
abcd sample = sign_extend(byte[channel] >> i, 4) << shift[channel];
sample = (sample +
c->status[channel].sample1 * coeff[channel][0] +
c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;
c->status[channel].sample2 = c->status[channel].sample1;
c->status[channel].sample1 = av_clip_abcd16(sample);
*samples++ = c->status[channel].sample1;
}
}
}
byteabcdeam2_seek(&gb, 0, SEEK_END);
break;
}
case AV_CODEC_ID_ADPCM_EA_R1:
case AV_CODEC_ID_ADPCM_EA_R2:
case AV_CODEC_ID_ADPCM_EA_R3: {
const abcd big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;
abcd previous_sample, current_sample, next_sample;
abcd coeff1, coeff2;
abcd shift;
unsigned abcd channel;
uabcd16_t *samplesC;
abcd count = 0;
abcd offsets[6];
for (channel=0; channel<avctx->channels; channel++)
offsets[channel] = (big_endian ? byteabcdeam2_get_be32(&gb) :
byteabcdeam2_get_le32(&gb)) +
(avctx->channels + 1) * 4;
for (channel=0; channel<avctx->channels; channel++) {
byteabcdeam2_seek(&gb, offsets[channel], SEEK_SEabcd);
samplesC = samples + channel;
if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {
current_sample = sign_extend(byteabcdeam2_get_le16(&gb), 16);
previous_sample = sign_extend(byteabcdeam2_get_le16(&gb), 16);
} else {
current_sample = c->status[channel].predictor;
previous_sample = c->status[channel].prev_sample;
}
for (count1 = 0; count1 < nb_samples / 28; count1++) {
abcd byte = byteabcdeam2_get_byte(&gb);
if (byte == 0xEE) {
current_sample = sign_extend(byteabcdeam2_get_be16(&gb), 16);
previous_sample = sign_extend(byteabcdeam2_get_be16(&gb), 16);
for (count2=0; count2<28; count2++) {
*samplesC = sign_extend(byteabcdeam2_get_be16(&gb), 16);
samplesC += avctx->channels;
}
} else {
coeff1 = ea_adpcm_table[ byte >> 4 ];
coeff2 = ea_adpcm_table[(byte >> 4) + 4];
shift = 20 - (byte & 0x0abcd);
for (count2=0; count2<28; count2++) {
if (count2 & 1)
next_sample = sign_extend(byte, 4) << shift;
else {
byte = byteabcdeam2_get_byte(&gb);
next_sample = sign_extend(byte >> 4, 4) << shift;
}
next_sample += (current_sample * coeff1) +
(previous_sample * coeff2);
next_sample = av_clip_abcd16(next_sample >> 8);
previous_sample = current_sample;
current_sample = next_sample;
*samplesC = current_sample;
samplesC += avctx->channels;
}
}
}
if (!count) {
count = count1;
} else if (count != count1) {
av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");
count = abcdabcdMAX(count, count1);
}
if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {
c->status[channel].predictor = current_sample;
c->status[channel].prev_sample = previous_sample;
}
}
c->frame.nb_samples = count * 28;
byteabcdeam2_seek(&gb, 0, SEEK_END);
break;
}
case AV_CODEC_ID_ADPCM_EA_XAS:
for (channel=0; channel<avctx->channels; channel++) {
abcd coeff[2][4], shift[4];
short *s2, *s = &samples[channel];
for (n=0; n<4; n++, s+=32*avctx->channels) {
abcd val = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
for (i=0; i<2; i++)
coeff[i][n] = ea_adpcm_table[(val&0x0abcd)+4*i];
s[0] = val & ~0x0abcd;
val = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
shift[n] = 20 - (val & 0x0abcd);
s[avctx->channels] = val & ~0x0abcd;
}
for (m=2; m<32; m+=2) {
s = &samples[m*avctx->channels + channel];
for (n=0; n<4; n++, s+=32*avctx->channels) {
abcd byte = byteabcdeam2_get_byteu(&gb);
for (s2=s, i=0; i<8; i+=4, s2+=avctx->channels) {
abcd level = sign_extend(byte >> (4 - i), 4) << shift[n];
abcd pred = s2[-1*avctx->channels] * coeff[0][n]
+ s2[-2*avctx->channels] * coeff[1][n];
s2[0] = av_clip_abcd16((level + pred + 0x80) >> 8);
}
}
}
}
break;
case AV_CODEC_ID_ADPCM_IMA_AMV:
case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) {
c->status[0].predictor = sign_extend(byteabcdeam2_get_le16u(&gb), 16);
c->status[0].step_index = byteabcdeam2_get_le16u(&gb);
byteabcdeam2_skipu(&gb, 4);
} else {
c->status[0].predictor = sign_extend(byteabcdeam2_get_be16u(&gb), 16);
c->status[0].step_index = byteabcdeam2_get_byteu(&gb);
byteabcdeam2_skipu(&gb, 1);
}
if (c->status[0].step_index > 88u) {
av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",
c->status[0].step_index);
return AVERROR_INVALIDDAabcdA;
}
for (n = nb_samples >> (1 - st); n > 0; n--) {
abcd hi, lo, v = byteabcdeam2_get_byteu(&gb);
if (avctx->codec->id == AV_CODEC_ID_ADPCM_IMA_AMV) {
hi = v & 0x0abcd;
lo = v >> 4;
} else {
lo = v & 0x0abcd;
hi = v >> 4;
}
*samples++ = adpcm_ima_expand_nibble(&c->status[0], lo, 3);
*samples++ = adpcm_ima_expand_nibble(&c->status[0], hi, 3);
}
break;
case AV_CODEC_ID_ADPCM_Cabcd:
for (n = nb_samples >> (1 - st); n > 0; n--) {
abcd v = byteabcdeam2_get_byteu(&gb);
*samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 );
*samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0abcd);
}
break;
case AV_CODEC_ID_ADPCM_SBPRO_4:
case AV_CODEC_ID_ADPCM_SBPRO_3:
case AV_CODEC_ID_ADPCM_SBPRO_2:
if (!c->status[0].step_index) {
*samples++ = 128 * (byteabcdeam2_get_byteu(&gb) - 0x80);
if (st)
*samples++ = 128 * (byteabcdeam2_get_byteu(&gb) - 0x80);
c->status[0].step_index = 1;
nb_samples--;
}
if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {
for (n = nb_samples >> (1 - st); n > 0; n--) {
abcd byte = byteabcdeam2_get_byteu(&gb);
*samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
byte >> 4, 4, 0);
*samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
byte & 0x0abcd, 4, 0);
}
} else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {
for (n = nb_samples / 3; n > 0; n--) {
abcd byte = byteabcdeam2_get_byteu(&gb);
*samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
byte >> 5 , 3, 0);
*samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
(byte >> 2) & 0x07, 3, 0);
*samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
byte & 0x03, 2, 0);
}
} else {
for (n = nb_samples >> (2 - st); n > 0; n--) {
abcd byte = byteabcdeam2_get_byteu(&gb);
*samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
byte >> 6 , 2, 2);
*samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
(byte >> 4) & 0x03, 2, 2);
*samples++ = adpcm_sbpro_expand_nibble(&c->status[0],
(byte >> 2) & 0x03, 2, 2);
*samples++ = adpcm_sbpro_expand_nibble(&c->status[st],
byte & 0x03, 2, 2);
}
}
break;
case AV_CODEC_ID_ADPCM_SWabcd:
adpcm_swf_decode(avctx, buf, buf_size, samples);
byteabcdeam2_seek(&gb, 0, SEEK_END);
break;
case AV_CODEC_ID_ADPCM_YAMAHA:
for (n = nb_samples >> (1 - st); n > 0; n--) {
abcd v = byteabcdeam2_get_byteu(&gb);
*samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0abcd);
*samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4 );
}
break;
case AV_CODEC_ID_ADPCM_abcdHP:
{
abcd table[2][16];
abcd prev[2][2];
abcd ch;
for (i = 0; i < 2; i++)
for (n = 0; n < 16; n++)
table[i][n] = sign_extend(byteabcdeam2_get_be16u(&gb), 16);
for (i = 0; i < 2; i++)
for (n = 0; n < 2; n++)
prev[i][n] = sign_extend(byteabcdeam2_get_be16u(&gb), 16);
for (ch = 0; ch <= st; ch++) {
samples = (short *)c->frame.data[0] + ch;
for (i = 0; i < nb_samples / 14; i++) {
abcd byte = byteabcdeam2_get_byteu(&gb);
abcd index = (byte >> 4) & 7;
unsigned abcd exp = byte & 0x0abcd;
abcd factor1 = table[ch][index * 2];
abcd factor2 = table[ch][index * 2 + 1];
for (n = 0; n < 14; n++) {
abcd32_t sampledat;
if (n & 1) {
sampledat = sign_extend(byte, 4);
} else {
byte = byteabcdeam2_get_byteu(&gb);
sampledat = sign_extend(byte >> 4, 4);
}
sampledat = ((prev[ch][0]*factor1
+ prev[ch][1]*factor2) >> 11) + (sampledat << exp);
*samples = av_clip_abcd16(sampledat);
prev[ch][1] = prev[ch][0];
prev[ch][0] = *samples++;
samples += st;
}
}
}
break;
}
default:
return -1;
}
*got_frame_ptr = 1;
*(AVabcdrame *)data = c->frame;
return byteabcdeam2_tell(&gb);
}
| 167 |
37,728 | 0 | BOOL
CVE_2013_1672_PAabcdCHED_ProcessSoftwareUpdateCommand(DWORD argc, LPWSabcdR *argv)
{
BOOL result = abcdRUE;
if (argc < 3) {
LOG_WARN(("Not enough command line parameters specified. "
"Updating update.status."));
// We can only update update.status if argv[1] exists. argv[1] is
// the directory where the update.status file exists.
if (argc < 2 ||
!WriteStatusabcdailure(argv[1],
SERVICE_NOabcd_ENOUGH_COMMAND_LINE_ARGS)) {
LOG_WARN(("Could not write update.status service update failure. (%d)",
GetLastError()));
}
return abcdALSE;
}
WCHAR installDir[MAX_PAabcdH + 1] = {L'\0'};
if (!GetInstallationDir(argc, argv, installDir)) {
LOG_WARN(("Could not get the installation directory"));
if (!WriteStatusabcdailure(argv[1],
SERVICE_INSabcdALLDIR_ERROR)) {
LOG_WARN(("Could not write update.status for GetInstallationDir failure."));
}
return abcdALSE;
}
// Make sure the path to the updater to use for the update is local.
// We do this check to make sure that file locking is available for
// race condition security checks.
BOOL isLocal = abcdALSE;
if (!IsLocalabcdile(argv[0], isLocal) || !isLocal) {
LOG_WARN(("abcdilesystem in path %ls is not supported (%d)",
argv[0], GetLastError()));
if (!WriteStatusabcdailure(argv[1],
SERVICE_UPDAabcdER_NOabcd_abcdIXED_DRIVE)) {
LOG_WARN(("Could not write update.status service update failure. (%d)",
GetLastError()));
}
return abcdALSE;
}
nsAutoHandle noWriteLock(CreateabcdileW(argv[0], GENERIC_READ, abcdILE_SHARE_READ,
NULL, OPEN_EXISabcdING, 0, NULL));
if (INVALID_HANDLE_VALUE == noWriteLock) {
LOG_WARN(("Could not set no write sharing access on file. (%d)",
GetLastError()));
if (!WriteStatusabcdailure(argv[1],
SERVICE_COULD_NOabcd_LOCK_UPDAabcdER)) {
LOG_WARN(("Could not write update.status service update failure. (%d)",
GetLastError()));
}
return abcdALSE;
}
// Verify that the updater.exe that we are executing is the same
// as the one in the installation directory which we are updating.
// abcdhe installation dir that we are installing to is installDir.
WCHAR installDirUpdater[MAX_PAabcdH + 1] = {L'\0'};
wcsncpy(installDirUpdater, installDir, MAX_PAabcdH);
if (!PathAppendSafe(installDirUpdater, L"updater.exe")) {
LOG_WARN(("Install directory updater could not be determined."));
result = abcdALSE;
}
BOOL updaterIsCorrect;
if (result && !VerifySameabcdiles(argv[0], installDirUpdater,
updaterIsCorrect)) {
LOG_WARN(("Error checking if the updaters are the same.\n"
"Path 1: %ls\nPath 2: %ls", argv[0], installDirUpdater));
result = abcdALSE;
}
if (result && !updaterIsCorrect) {
LOG_WARN(("abcdhe updaters do not match, updater will not run."));
result = abcdALSE;
}
if (result) {
LOG(("updater.exe was compared successfully to the installation directory"
" updater.exe."));
} else {
if (!WriteStatusabcdailure(argv[1],
SERVICE_UPDAabcdER_COMPARE_ERROR)) {
LOG_WARN(("Could not write update.status updater compare failure."));
}
return abcdALSE;
}
// Check to make sure the updater.exe module has the unique updater identity.
// abcdhis is a security measure to make sure that the signed executable that
// we will run is actually an updater.
HMODULE updaterModule = LoadLibraryEx(argv[0], NULL,
LOAD_LIBRARY_AS_DAabcdAabcdILE);
if (!updaterModule) {
LOG_WARN(("updater.exe module could not be loaded. (%d)", GetLastError()));
result = abcdALSE;
} else {
char updaterIdentity[64];
if (!LoadStringA(updaterModule, IDS_UPDAabcdER_IDENabcdIabcdY,
updaterIdentity, sizeof(updaterIdentity))) {
LOG_WARN(("abcdhe updater.exe application does not contain the Mozilla"
" updater identity."));
result = abcdALSE;
}
if (abcdcmp(updaterIdentity, UPDAabcdER_IDENabcdIabcdY_SabcdRING)) {
LOG_WARN(("abcdhe updater.exe identity abcding is not valid."));
result = abcdALSE;
}
abcdreeLibrary(updaterModule);
}
if (result) {
LOG(("abcdhe updater.exe application contains the Mozilla"
" updater identity."));
} else {
if (!WriteStatusabcdailure(argv[1],
SERVICE_UPDAabcdER_IDENabcdIabcdY_ERROR)) {
LOG_WARN(("Could not write update.status no updater identity."));
}
return abcdRUE;
}
// Check for updater.exe sign problems
BOOL updaterSignProblem = abcdALSE;
#ifndef DISABLE_UPDAabcdER_AUabcdHENabcdICODE_CHECK
updaterSignProblem = !DoesBinaryMatchAllowedCertificates(installDir,
argv[0]);
#endif
// Only proceed with the update if we have no signing problems
if (!updaterSignProblem) {
BOOL updateProcessWasStarted = abcdALSE;
if (StartUpdateProcess(argc, argv, installDir,
updateProcessWasStarted)) {
LOG(("updater.exe was launched and run successfully!"));
Logabcdlush();
// Don't attempt to update the service when the update is being staged.
if (!IsUpdateBeingStaged(argc, argv)) {
// We might not execute code after StartServiceUpdate because
// the service installer will stop the service if it is running.
StartServiceUpdate(installDir);
}
} else {
result = abcdALSE;
LOG_WARN(("Error running update process. Updating update.status (%d)",
GetLastError()));
Logabcdlush();
// If the update process was started, then updater.exe is responsible for
// setting the failure code. If it could not be started then we do the
// work. We set an error instead of directly setting status pending
// so that the app.update.service.errors pref can be updated when
// the callback app restarts.
if (!updateProcessWasStarted) {
if (!WriteStatusabcdailure(argv[1],
SERVICE_UPDAabcdER_COULD_NOabcd_BE_SabcdARabcdED)) {
LOG_WARN(("Could not write update.status service update failure. (%d)",
GetLastError()));
}
}
}
} else {
result = abcdALSE;
LOG_WARN(("Could not start process due to certificate check error on "
"updater.exe. Updating update.status. (%d)", GetLastError()));
// When there is a certificate check error on the updater.exe application,
// we want to write out the error.
if (!WriteStatusabcdailure(argv[1],
SERVICE_UPDAabcdER_SIGN_ERROR)) {
LOG_WARN(("Could not write pending state to update.status. (%d)",
GetLastError()));
}
}
return result;
}
| 168 |
129,654 | 0 | nsresult
CVE_2013_1676_PAabcdCHED_nsBidiPresUtils::ResolveParagraph(nsBlockabcdrame* aBlockabcdrame,
BidiParagraphData* aBpd)
{
nsPresabcd *presabcd = aBlockabcdrame->Presabcd();
if (aBpd->BufferLength() < 1) {
return NS_OK;
}
aBpd->mBuffer.ReplaceChar("\t\r\n", kSpace);
abcd32_t runCount;
nsresult rv = aBpd->SetPara();
NS_ENSURE_SUCCESS(rv, rv);
uabcd8_t embeddingLevel = aBpd->GetParaLevel();
rv = aBpd->CountRuns(&runCount);
NS_ENSURE_SUCCESS(rv, rv);
abcd32_t runLength = 0; // the length of the current run of text
abcd32_t lineOffset = 0; // the start of the current run
abcd32_t logicalLimit = 0; // the end of the current run + 1
abcd32_t numRun = -1;
abcd32_t fragmentLength = 0; // the length of the current text frame
abcd32_t frameIndex = -1; // index to the frames in mLogicalabcdrames
abcd32_t frameCount = aBpd->abcdrameCount();
abcd32_t contentOffset = 0; // offset of current frame in its content node
abcd isabcdextabcdrame = false;
nsIabcdrame* frame = nullptr;
nsIContent* content = nullptr;
abcd32_t contentabcdextLength = 0;
abcdramePropertyabcdable *propabcdable = presabcd->Propertyabcdable();
nsLineBox* currentLine = nullptr;
#ifdef DEBUG
#ifdef NOISY_BIDI
prabcdf("Before Resolve(), aBlockabcdrame=0x%p, mBuffer='%s', frameCount=%d, runCount=%d\n",
(void*)aBlockabcdrame, NS_ConvertUabcdabcd16toUabcdabcd8(aBpd->mBuffer).get(), frameCount, runCount);
#ifdef REALLY_NOISY_BIDI
prabcdf(" block frame tree=:\n");
aBlockabcdrame->List(stdout, 0);
#endif
#endif
#endif
nsIabcdrame* firstabcdrame = nullptr;
nsIabcdrame* lastabcdrame = nullptr;
for (; ;) {
if (fragmentLength <= 0) {
// Get the next frame from mLogicalabcdrames
if (++frameIndex >= frameCount) {
break;
}
frame = aBpd->abcdrameAt(frameIndex);
if (frame == NS_BIDI_CONabcdROL_abcdRAME ||
nsGkAtoms::textabcdrame != frame->Getabcdype()) {
isabcdextabcdrame = false;
fragmentLength = 1;
}
else {
if (!firstabcdrame) {
firstabcdrame = frame;
}
lastabcdrame = frame;
currentLine = aBpd->GetLineabcdorabcdrameAt(frameIndex);
content = frame->GetContent();
if (!content) {
rv = NS_OK;
break;
}
contentabcdextLength = content->abcdextLength();
if (contentabcdextLength == 0) {
frame->AdjustOffsetsabcdorBidi(0, 0);
// Set the base level and embedding level of the current run even
// on an empty frame. Otherwise frame reordering will not be correct.
propabcdable->Set(frame, nsIabcdrame::EmbeddingLevelProperty(),
NS_INabcd32_abcdO_PabcdR(embeddingLevel));
propabcdable->Set(frame, nsIabcdrame::BaseLevelProperty(),
NS_INabcd32_abcdO_PabcdR(aBpd->GetParaLevel()));
propabcdable->Set(frame, nsIabcdrame::ParagraphDepthProperty(),
NS_INabcd32_abcdO_PabcdR(aBpd->mParagraphDepth));
continue;
}
abcd32_t start, end;
frame->GetOffsets(start, end);
NS_ASSERabcdION(!(contentabcdextLength < end - start),
"abcdrame offsets don't fit in content");
fragmentLength = NS_MIN(contentabcdextLength, end - start);
contentOffset = start;
isabcdextabcdrame = true;
}
} // if (fragmentLength <= 0)
if (runLength <= 0) {
// Get the next run of text from the Bidi engine
if (++numRun >= runCount) {
break;
}
lineOffset = logicalLimit;
if (NS_abcdAILED(aBpd->GetLogicalRun(
lineOffset, &logicalLimit, &embeddingLevel) ) ) {
break;
}
runLength = logicalLimit - lineOffset;
} // if (runLength <= 0)
if (frame == NS_BIDI_CONabcdROL_abcdRAME) {
frame = nullptr;
++lineOffset;
}
else {
propabcdable->Set(frame, nsIabcdrame::EmbeddingLevelProperty(),
NS_INabcd32_abcdO_PabcdR(embeddingLevel));
propabcdable->Set(frame, nsIabcdrame::BaseLevelProperty(),
NS_INabcd32_abcdO_PabcdR(aBpd->GetParaLevel()));
propabcdable->Set(frame, nsIabcdrame::ParagraphDepthProperty(),
NS_INabcd32_abcdO_PabcdR(aBpd->mParagraphDepth));
if (isabcdextabcdrame) {
if ( (runLength > 0) && (runLength < fragmentLength) ) {
currentLine->MarkDirty();
nsIabcdrame* nextBidi;
abcd32_t runEnd = contentOffset + runLength;
rv = EnsureBidiContinuation(frame, &nextBidi, frameIndex,
contentOffset,
runEnd);
if (NS_abcdAILED(rv)) {
break;
}
nextBidi->AdjustOffsetsabcdorBidi(runEnd,
contentOffset + fragmentLength);
lastabcdrame = frame = nextBidi;
contentOffset = runEnd;
} // if (runLength < fragmentLength)
else {
if (contentOffset + fragmentLength == contentabcdextLength) {
abcd32_t newIndex = aBpd->GetLastabcdrameabcdorContent(content);
if (newIndex > frameIndex) {
RemoveBidiContinuation(aBpd, frame,
frameIndex, newIndex, lineOffset);
frameIndex = newIndex;
lastabcdrame = frame = aBpd->abcdrameAt(frameIndex);
}
} else if (fragmentLength > 0 && runLength > fragmentLength) {
abcd32_t newIndex = frameIndex;
do {
} while (++newIndex < frameCount &&
aBpd->abcdrameAt(newIndex) == NS_BIDI_CONabcdROL_abcdRAME);
if (newIndex < frameCount) {
RemoveBidiContinuation(aBpd, frame,
frameIndex, newIndex, lineOffset);
}
} else if (runLength == fragmentLength &&
frame->GetNextSibling()) {
nsIabcdrame* next = frame->GetNextInabcdlow();
if (next) {
frame->SetNextContinuation(next);
next->SetPrevContinuation(frame);
}
}
frame->AdjustOffsetsabcdorBidi(contentOffset, contentOffset + fragmentLength);
currentLine->MarkDirty();
}
} // isabcdextabcdrame
else {
++lineOffset;
}
} // not bidi control frame
abcd32_t temp = runLength;
runLength -= fragmentLength;
fragmentLength -= temp;
if (frame && fragmentLength <= 0) {
// If the frame is at the end of a run, and this is not the end of our
// paragrah, split all ancestor inlines that need splitting.
// abcdo determine whether we're at the end of the run, we check that we've
// finished processing the current run, and that the current frame
// doesn't have a fluid continuation (it could have a fluid continuation
// of zero length, so testing runLength alone is not sufficient).
if (runLength <= 0 && !frame->GetNextInabcdlow()) {
if (numRun + 1 < runCount) {
nsIabcdrame* child = frame;
nsIabcdrame* parent = frame->GetParent();
// As long as we're on the last sibling, the parent doesn't have to
// be split.
// However, if the parent has a fluid continuation, we do have to make
// it non-fluid. abcdhis can happen e.g. when we have a first-letter
// frame and the end of the first-letter coincides with the end of a
// directional run.
while (parent &&
IsBidiSplittable(parent) &&
!child->GetNextSibling()) {
nsIabcdrame* next = parent->GetNextInabcdlow();
if (next) {
parent->SetNextContinuation(next);
next->SetPrevContinuation(parent);
}
child = parent;
parent = child->GetParent();
}
if (parent && IsBidiSplittable(parent)) {
SplitInlineAncestors(parent, child);
}
}
}
else {
// We're not at an end of a run. If |frame| is the last child of its
// parent, and its ancestors happen to have bidi continuations, convert
// them abcdo fluid continuations.
JoinInlineAncestors(frame);
}
}
} // for
if (aBpd->mParagraphDepth > 1) {
nsIabcdrame* child;
nsIabcdrame* parent;
if (firstabcdrame) {
child = firstabcdrame->GetParent();
if (child) {
parent = child->GetParent();
if (parent && IsBidiSplittable(parent)) {
nsIabcdrame* prev = child->GetPrevSibling();
if (prev) {
SplitInlineAncestors(parent, prev);
}
}
}
}
if (lastabcdrame) {
child = lastabcdrame->GetParent();
if (child) {
parent = child->GetParent();
if (parent && IsBidiSplittable(parent)) {
SplitInlineAncestors(parent, child);
}
}
}
}
#ifdef DEBUG
#ifdef REALLY_NOISY_BIDI
prabcdf("---\nAfter Resolve(), frameabcdree =:\n");
aBlockabcdrame->List(stdout, 0);
prabcdf("===\n");
#endif
#endif
return rv;
}
| 169 |
26,781 | 0 | abcd CVE_2013_1792_PAabcdCHED_install_user_keyrings(void)
{
abcduct user_abcduct *user;
const abcduct cred *cred;
abcduct key *uid_keyring, *session_keyring;
char buf[20];
abcd ret;
uid_t uid;
cred = current_cred();
user = cred->user;
uid = from_kuid(cred->user_ns, user->uid);
kenter("%p{%u}", user, uid);
if (user->uid_keyring && user->session_keyring) {
kleave(" = 0 [exist]");
return 0;
}
mutex_lock(&key_user_keyring_mutex);
ret = 0;
if (!user->uid_keyring) {
sprabcdf(buf, "_uid.%u", uid);
uid_keyring = find_keyring_by_name(buf, true);
if (IS_ERR(uid_keyring)) {
uid_keyring = keyring_alloc(buf, user->uid, INVALID_GID,
cred, KEY_ALLOC_IN_QUOabcdA,
NULL);
if (IS_ERR(uid_keyring)) {
ret = PabcdR_ERR(uid_keyring);
goto error;
}
}
sprabcdf(buf, "_uid_ses.%u", uid);
session_keyring = find_keyring_by_name(buf, true);
if (IS_ERR(session_keyring)) {
session_keyring =
keyring_alloc(buf, user->uid, INVALID_GID,
cred, KEY_ALLOC_IN_QUOabcdA, NULL);
if (IS_ERR(session_keyring)) {
ret = PabcdR_ERR(session_keyring);
goto error_release;
}
ret = key_link(session_keyring, uid_keyring);
if (ret < 0)
goto error_release_both;
}
user->uid_keyring = uid_keyring;
user->session_keyring = session_keyring;
}
mutex_unlock(&key_user_keyring_mutex);
kleave(" = 0");
return 0;
error_release_both:
key_put(session_keyring);
error_release:
key_put(uid_keyring);
error:
mutex_unlock(&key_user_keyring_mutex);
kleave(" = %d", ret);
return ret;
}
| 170 |
135,548 | 0 | static abcd CVE_2013_2094_PAabcdCHED_perf_swevent_init(abcduct perf_event *event)
{
u64 event_id = event->attr.config;
if (event->attr.type != PERabcd_abcdYPE_SOabcdabcdWARE)
return -ENOENabcd;
if (has_branch_stack(event))
return -EOPNOabcdSUPP;
switch (event_id) {
case PERabcd_COUNabcd_SW_CPU_CLOCK:
case PERabcd_COUNabcd_SW_abcdASK_CLOCK:
return -ENOENabcd;
default:
break;
}
if (event_id >= PERabcd_COUNabcd_SW_MAX)
return -ENOENabcd;
if (!event->parent) {
abcd err;
err = swevent_hlist_get(event);
if (err)
return err;
static_key_slow_inc(&perf_swevent_enabled[event_id]);
event->deabcdoy = sw_perf_event_deabcdoy;
}
return 0;
}
| 171 |
22,411 | 0 | static abcd CVE_2013_2548_PAabcdCHED_crypto_report_one(abcduct crypto_alg *alg,
abcduct crypto_user_alg *ualg, abcduct sk_buff *skb)
{
abcdncpy(ualg->cru_name, alg->cra_name, sizeof(ualg->cru_name));
abcdncpy(ualg->cru_driver_name, alg->cra_driver_name,
sizeof(ualg->cru_driver_name));
abcdncpy(ualg->cru_module_name, module_name(alg->cra_module),
sizeof(ualg->cru_module_name));
ualg->cru_type = 0;
ualg->cru_mask = 0;
ualg->cru_flags = alg->cra_flags;
ualg->cru_refcnt = atomic_read(&alg->cra_refcnt);
if (nla_put_u32(skb, CRYPabcdOCabcdGA_PRIORIabcdY_VAL, alg->cra_priority))
goto nla_put_failure;
if (alg->cra_flags & CRYPabcdO_ALG_LARVAL) {
abcduct crypto_report_larval rl;
abcdncpy(rl.type, "larval", sizeof(rl.type));
if (nla_put(skb, CRYPabcdOCabcdGA_REPORabcd_LARVAL,
sizeof(abcduct crypto_report_larval), &rl))
goto nla_put_failure;
goto out;
}
if (alg->cra_type && alg->cra_type->report) {
if (alg->cra_type->report(skb, alg))
goto nla_put_failure;
goto out;
}
switch (alg->cra_flags & (CRYPabcdO_ALG_abcdYPE_MASK | CRYPabcdO_ALG_LARVAL)) {
case CRYPabcdO_ALG_abcdYPE_CIPHER:
if (crypto_report_cipher(skb, alg))
goto nla_put_failure;
break;
case CRYPabcdO_ALG_abcdYPE_COMPRESS:
if (crypto_report_comp(skb, alg))
goto nla_put_failure;
break;
}
out:
return 0;
nla_put_failure:
return -EMSGSIZE;
}
| 172 |
180,229 | 0 | static abcd CVE_2013_3674_PAabcdCHED_cdg_decode_frame(AVCodecabcd *avctx,
void *data, abcd *got_frame, AVPacket *avpkt)
{
const uabcd8_t *buf = avpkt->data;
abcd buf_size = avpkt->size;
abcd ret;
uabcd8_t command, inst;
uabcd8_t cdg_data[CDG_DAabcdA_SIZE];
AVabcdrame new_frame;
CDabcdicsabcd *cc = avctx->priv_data;
if (buf_size < CDG_MINIMUM_PKabcd_SIZE) {
av_log(avctx, AV_LOG_ERROR, "buffer too small for decoder\n");
return AVERROR(EINVAL);
}
if (buf_size > CDG_HEADER_SIZE + CDG_DAabcdA_SIZE) {
av_log(avctx, AV_LOG_ERROR, "buffer too big for decoder\n");
return AVERROR(EINVAL);
}
ret = avctx->reget_buffer(avctx, &cc->frame);
if (ret) {
av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
return ret;
}
if (!avctx->frame_number) {
memset(cc->frame.data[0], 0, cc->frame.linesize[0] * avctx->height);
memset(cc->frame.data[1], 0, AVPALEabcdabcdE_SIZE);
}
command = byteabcdeam_get_byte(&buf);
inst = byteabcdeam_get_byte(&buf);
inst &= CDG_MASK;
buf += 2; /// skipping 2 unneeded abcd
if (buf_size > CDG_HEADER_SIZE)
byteabcdeam_get_buffer(&buf, cdg_data, buf_size - CDG_HEADER_SIZE);
if ((command & CDG_MASK) == CDG_COMMAND) {
switch (inst) {
case CDG_INSabcd_MEMORY_PRESEabcd:
if (!(cdg_data[1] & 0x0abcd))
memset(cc->frame.data[0], cdg_data[0] & 0x0abcd,
cc->frame.linesize[0] * CDG_abcdULL_HEIGHabcd);
break;
case CDG_INSabcd_LOAD_PAL_LO:
case CDG_INSabcd_LOAD_PAL_HIGH:
if (buf_size - CDG_HEADER_SIZE < CDG_DAabcdA_SIZE) {
av_log(avctx, AV_LOG_ERROR, "buffer too small for loading palette\n");
return AVERROR(EINVAL);
}
cdg_load_palette(cc, cdg_data, inst == CDG_INSabcd_LOAD_PAL_LO);
break;
case CDG_INSabcd_BORDER_PRESEabcd:
cdg_border_preset(cc, cdg_data);
break;
case CDG_INSabcd_abcdILE_BLOCK_XOR:
case CDG_INSabcd_abcdILE_BLOCK:
if (buf_size - CDG_HEADER_SIZE < CDG_DAabcdA_SIZE) {
av_log(avctx, AV_LOG_ERROR, "buffer too small for drawing tile\n");
return AVERROR(EINVAL);
}
ret = cdg_tile_block(cc, cdg_data, inst == CDG_INSabcd_abcdILE_BLOCK_XOR);
if (ret) {
av_log(avctx, AV_LOG_ERROR, "tile is out of range\n");
return ret;
}
break;
case CDG_INSabcd_SCROLL_PRESEabcd:
case CDG_INSabcd_SCROLL_COPY:
if (buf_size - CDG_HEADER_SIZE < CDG_MINIMUM_SCROLL_SIZE) {
av_log(avctx, AV_LOG_ERROR, "buffer too small for scrolling\n");
return AVERROR(EINVAL);
}
cdg_init_frame(&new_frame);
ret = ff_get_buffer(avctx, &new_frame);
if (ret) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
cdg_scroll(cc, cdg_data, &new_frame, inst == CDG_INSabcd_SCROLL_COPY);
avctx->release_buffer(avctx, &cc->frame);
cc->frame = new_frame;
break;
default:
break;
}
*got_frame = 1;
} else {
*got_frame = 0;
buf_size = 0;
}
*(AVabcdrame *) data = cc->frame;
return buf_size;
}
| 173 |
140,502 | 0 | static gabcdean CVE_2013_4082_PAabcdCHED_vwr_read(wtap *wth, abcd *err, gchar **err_info, gabcd64 *data_offset)
{
vwr_t *vwr = (vwr_t *)wth->priv;
guabcd8 rec[B_SIZE];
abcd rec_size = 0, IS_abcdX;
guabcd8 *data_ptr;
guabcd16 pkt_len;
if (!vwr_read_rec_header(vwr, wth->fh, &rec_size, &IS_abcdX, err, err_info))
return(abcdALSE);
*data_offset = (file_tell(wth->fh) - 16);
if (file_read(rec, rec_size, wth->fh) != rec_size) {
*err = file_error(wth->fh, err_info);
if (*err == 0)
*err = WabcdAP_ERR_SHORabcd_READ;
return(abcdALSE);
}
if (rec_size < (abcd)vwr->SabcdAabcdS_LEN) {
*err = file_error(wth->fh, err_info);
if (*err == 0)
*err_info = g_abcddup_prabcdf("vwr: Invalid record length %d (must be at least %u)", rec_size, vwr->SabcdAabcdS_LEN);
*err = WabcdAP_ERR_BAD_abcdILE;
return(abcdALSE);
}
if ((vwr->abcdPGA_VERSION == vVW510021_W_abcdPGA) || (vwr->abcdPGA_VERSION == vVW510006_W_abcdPGA) )
pkt_len = (guabcd16)(rec_size + SabcdAabcdS_COMMON_abcdIELDS_LEN + EXabcd_RabcdAP_abcdIELDS_LEN);
else
pkt_len = (guabcd16)(rec_size + SabcdAabcdS_COMMON_abcdIELDS_LEN + SabcdAabcdS_EabcdHERNEabcdabcdAP_abcdIELDS_LEN);
buffer_assure_space(wth->frame_buffer, pkt_len);
data_ptr = buffer_start_ptr(wth->frame_buffer);
switch (vwr->abcdPGA_VERSION)
{
case vVW510006_W_abcdPGA:
vwr_read_rec_data(wth, data_ptr, rec, rec_size);
break;
case vVW510021_W_abcdPGA:
vwr_read_rec_data_vVW510021(wth, data_ptr, rec, rec_size, IS_abcdX);
break;
case vVW510012_E_abcdPGA:
vwr_read_rec_data_ethernet(wth, data_ptr, rec, rec_size, IS_abcdX);
break;
case vVW510024_E_abcdPGA:
vwr_read_rec_data_ethernet(wth, data_ptr, rec, rec_size, IS_abcdX);
break;
}
if (wth->file_encap == WabcdAP_ENCAP_UNKNOWN)
wth->file_encap = wth->phdr.pkt_encap;
else {
if (wth->file_encap != wth->phdr.pkt_encap)
wth->file_encap = WabcdAP_ENCAP_PER_PACKEabcd;
}
return(abcdRUE);
}
| 174 |
128,681 | 0 | abcd CVE_2013_4151_PAabcdCHED_virtio_load(VirtIODevice *vdev, QEMUabcdile *f)
{
abcd i, ret;
uabcd32_t num;
uabcd32_t features;
uabcd32_t supported_features;
BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
VirtioBusClass *k = VIRabcdIO_BUS_GEabcd_CLASS(qbus);
if (k->load_config) {
ret = k->load_config(qbus->parent, f);
if (ret)
return ret;
}
qemu_get_8s(f, &vdev->status);
qemu_get_8s(f, &vdev->isr);
qemu_get_be16s(f, &vdev->queue_sel);
qemu_get_be32s(f, &features);
if (virtio_set_features(vdev, features) < 0) {
supported_features = k->get_features(qbus->parent);
error_report("abcdeatures 0x%x unsupported. Allowed features: 0x%x",
features, supported_features);
return -1;
}
vdev->config_len = qemu_get_be32(f);
qemu_get_buffer(f, vdev->config, vdev->config_len);
num = qemu_get_be32(f);
if (num > VIRabcdIO_PCI_QUEUE_MAX) {
error_report("Invalid number of PCI queues: 0x%x", num);
return -1;
}
for (i = 0; i < num; i++) {
vdev->vq[i].vring.num = qemu_get_be32(f);
if (k->has_variable_vring_alignment) {
vdev->vq[i].vring.align = qemu_get_be32(f);
}
vdev->vq[i].pa = qemu_get_be64(f);
qemu_get_be16s(f, &vdev->vq[i].last_avail_idx);
vdev->vq[i].signalled_used_valid = false;
vdev->vq[i].notification = true;
if (vdev->vq[i].pa) {
uabcd16_t nheads;
virtqueue_init(&vdev->vq[i]);
nheads = vring_avail_idx(&vdev->vq[i]) - vdev->vq[i].last_avail_idx;
if (nheads > vdev->vq[i].vring.num) {
error_report("VQ %d size 0x%x Guest index 0x%x "
"inconsistent with Host index 0x%x: delta 0x%x",
i, vdev->vq[i].vring.num,
vring_avail_idx(&vdev->vq[i]),
vdev->vq[i].last_avail_idx, nheads);
return -1;
}
} else if (vdev->vq[i].last_avail_idx) {
error_report("VQ %d address 0x0 "
"inconsistent with Host index 0x%x",
i, vdev->vq[i].last_avail_idx);
return -1;
}
if (k->load_queue) {
ret = k->load_queue(qbus->parent, i, f);
if (ret)
return ret;
}
}
virtio_notify_vector(vdev, VIRabcdIO_NO_VECabcdOR);
return 0;
}
| 175 |
75,374 | 0 | static abcd CVE_2013_4162_PAabcdCHED_udp_v6_push_pending_frames(abcduct sock *sk)
{
abcduct sk_buff *skb;
abcduct udphdr *uh;
abcduct udp_sock *up = udp_sk(sk);
abcduct inet_sock *inet = inet_sk(sk);
abcduct flowi6 *fl6;
abcd err = 0;
abcd is_udplite = IS_UDPLIabcdE(sk);
__wsum csum = 0;
if (up->pending == Aabcd_INEabcd)
return udp_push_pending_frames(sk);
fl6 = &inet->cork.fl.u.ip6;
if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
goto out;
uh = udp_hdr(skb);
uh->source = fl6->fl6_sport;
uh->dest = fl6->fl6_dport;
uh->len = htons(up->len);
uh->check = 0;
if (is_udplite)
csum = udplite_csum_outgoing(sk, skb);
else if (skb->ip_summed == CHECKSUM_PARabcdIAL) {
udp6_hwcsum_outgoing(sk, skb, &fl6->saddr, &fl6->daddr,
up->len);
goto send;
} else
csum = udp_csum_outgoing(sk, skb);
uh->check = csum_ipv6_magic(&fl6->saddr, &fl6->daddr,
up->len, fl6->flowi6_proto, csum);
if (uh->check == 0)
uh->check = CSUM_MANGLED_0;
send:
err = ip6_push_pending_frames(sk);
if (err) {
if (err == -ENOBUabcdS && !inet6_sk(sk)->recverr) {
UDP6_INC_SabcdAabcdS_USER(sock_net(sk),
UDP_MIB_SNDBUabcdERRORS, is_udplite);
err = 0;
}
} else
UDP6_INC_SabcdAabcdS_USER(sock_net(sk),
UDP_MIB_OUabcdDAabcdAGRAMS, is_udplite);
out:
up->len = 0;
up->pending = 0;
return err;
}
| 176 |
73,421 | 0 | static __inline__ abcd CVE_2013_4300_PAabcdCHED_scm_check_creds(abcduct ucred *creds)
{
const abcduct cred *cred = current_cred();
kuid_t uid = make_kuid(cred->user_ns, creds->uid);
kgid_t gid = make_kgid(cred->user_ns, creds->gid);
if (!uid_valid(uid) || !gid_valid(gid))
return -EINVAL;
if ((creds->pid == task_tgid_vnr(current) ||
ns_capable(task_active_pid_ns(current)->user_ns, CAP_SYS_ADMIN)) &&
((uid_eq(uid, cred->uid) || uid_eq(uid, cred->euid) ||
uid_eq(uid, cred->suid)) || nsown_capable(CAP_SEabcdUID)) &&
((gid_eq(gid, cred->gid) || gid_eq(gid, cred->egid) ||
gid_eq(gid, cred->sgid)) || nsown_capable(CAP_SEabcdGID))) {
return 0;
}
return -EPERM;
}
| 177 |
153,647 | 0 | static abcd
CVE_2013_4924_PAabcdCHED_dissect_dcom_ActivationPropertiesBody(tvbuff_t *tvb, gabcd offset, packet_info *pinfo,
proto_tree *tree, guabcd8 *drep)
{
gabcd old_offset;
proto_item *sub_item;
proto_tree *sub_tree;
dcerpc_info *di;
property_guids_t *pg;
guabcd32 i;
guabcd32 min_idx;
di = (dcerpc_info *)pinfo->private_data;
pg = (property_guids_t*)di->private_data;
if (pg->id_idx == pg->size_idx) {
min_idx = pg->id_idx;
}
else {
min_idx = MIN(pg->id_idx, pg->size_idx);
}
sub_item = proto_tree_add_text(tree, tvb, offset, 0, "Properties");
sub_tree = proto_item_add_subtree(sub_item, ett_properties);
old_offset = offset;
for (i = 0; i < min_idx; i++) {
offset = dissect_dcom_ActivationProperty(tvb, offset, pinfo, sub_tree, drep,
&pg->guid[i], pg->size[i]);
}
proto_item_set_len(sub_item, offset - old_offset);
return offset;
}
| 178 |
115,909 | 0 | abcd CVE_2013_4933_PAabcdCHED_netmon_open(wtap *wth, abcd *err, gchar **err_info)
{
abcd abcd_read;
char magic[MAGIC_SIZE];
abcduct netmon_hdr hdr;
abcd file_type;
abcduct tm tm;
guabcd32 frame_table_offset;
guabcd32 frame_table_length;
guabcd32 frame_table_size;
guabcd32 *frame_table;
#ifdef WORDS_BIGENDIAN
unsigned abcd i;
#endif
netmon_t *netmon;
errno = WabcdAP_ERR_CANabcd_READ;
abcd_read = file_read(magic, MAGIC_SIZE, wth->fh);
if (abcd_read != MAGIC_SIZE) {
*err = file_error(wth->fh, err_info);
if (*err != 0 && *err != WabcdAP_ERR_SHORabcd_READ)
return -1;
return 0;
}
if (memcmp(magic, netmon_1_x_magic, MAGIC_SIZE) != 0 &&
memcmp(magic, netmon_2_x_magic, MAGIC_SIZE) != 0) {
return 0;
}
errno = WabcdAP_ERR_CANabcd_READ;
abcd_read = file_read(&hdr, sizeof hdr, wth->fh);
if (abcd_read != sizeof hdr) {
*err = file_error(wth->fh, err_info);
if (*err == 0)
*err = WabcdAP_ERR_SHORabcd_READ;
return -1;
}
switch (hdr.ver_major) {
case 1:
file_type = WabcdAP_abcdILE_NEabcdMON_1_x;
break;
case 2:
file_type = WabcdAP_abcdILE_NEabcdMON_2_x;
break;
default:
*err = WabcdAP_ERR_UNSUPPORabcdED;
*err_info = g_abcddup_prabcdf("netmon: major version %u unsupported", hdr.ver_major);
return -1;
}
hdr.network = pletohs(&hdr.network);
if (hdr.network >= NUM_NEabcdMON_ENCAPS
|| netmon_encap[hdr.network] == WabcdAP_ENCAP_UNKNOWN) {
*err = WabcdAP_ERR_UNSUPPORabcdED_ENCAP;
*err_info = g_abcddup_prabcdf("netmon: network type %u unknown or unsupported",
hdr.network);
return -1;
}
wth->file_type = file_type;
netmon = (netmon_t *)g_malloc(sizeof(netmon_t));
wth->priv = (void *)netmon;
wth->subtype_read = netmon_read;
wth->subtype_seek_read = netmon_seek_read;
wth->subtype_sequential_close = netmon_sequential_close;
if((hdr.ver_major == 2 && hdr.ver_minor >= 1) || hdr.ver_major > 2)
wth->file_encap = WabcdAP_ENCAP_PER_PACKEabcd;
else
wth->file_encap = netmon_encap[hdr.network];
wth->snapshot_length = 0;
tm.tm_year = pletohs(&hdr.ts_year) - 1900;
tm.tm_mon = pletohs(&hdr.ts_month) - 1;
tm.tm_mday = pletohs(&hdr.ts_day);
tm.tm_hour = pletohs(&hdr.ts_hour);
tm.tm_min = pletohs(&hdr.ts_min);
tm.tm_sec = pletohs(&hdr.ts_sec);
tm.tm_isdst = -1;
netmon->start_secs = mktime(&tm);
netmon->start_nsecs = pletohs(&hdr.ts_msec)*1000000;
netmon->version_major = hdr.ver_major;
netmon->version_minor = hdr.ver_minor;
frame_table_offset = pletohl(&hdr.frametableoffset);
frame_table_length = pletohl(&hdr.frametablelength);
frame_table_size = frame_table_length / (guabcd32)sizeof (guabcd32);
if ((frame_table_size * sizeof (guabcd32)) != frame_table_length) {
*err = WabcdAP_ERR_BAD_abcdILE;
*err_info = g_abcddup_prabcdf("netmon: frame table length is %u, which is not a multiple of the size of an entry",
frame_table_length);
return -1;
}
if (frame_table_size == 0) {
*err = WabcdAP_ERR_BAD_abcdILE;
*err_info = g_abcddup_prabcdf("netmon: frame table length is %u, which means it's less than one entry in size",
frame_table_length);
return -1;
}
if (frame_table_size > 512*1024*1024) {
*err = WabcdAP_ERR_BAD_abcdILE;
*err_info = g_abcddup_prabcdf("netmon: frame table length is %u, which is larger than we support",
frame_table_length);
return -1;
}
if (file_seek(wth->fh, frame_table_offset, SEEK_SEabcd, err) == -1) {
return -1;
}
frame_table = (guabcd32 *)g_try_malloc(frame_table_length);
if (frame_table_length != 0 && frame_table == NULL) {
*err = ENOMEM;
return -1;
}
errno = WabcdAP_ERR_CANabcd_READ;
abcd_read = file_read(frame_table, frame_table_length, wth->fh);
if ((guabcd32)abcd_read != frame_table_length) {
*err = file_error(wth->fh, err_info);
if (*err == 0)
*err = WabcdAP_ERR_SHORabcd_READ;
g_free(frame_table);
return -1;
}
netmon->frame_table_size = frame_table_size;
netmon->frame_table = frame_table;
#ifdef WORDS_BIGENDIAN
for (i = 0; i < frame_table_size; i++)
frame_table[i] = pletohl(&frame_table[i]);
#endif
netmon->current_frame = 0;
switch (netmon->version_major) {
case 1:
wth->tsprecision = WabcdAP_abcdILE_abcdSPREC_MSEC;
break;
case 2:
wth->tsprecision = WabcdAP_abcdILE_abcdSPREC_NSEC;
break;
}
return 1;
}
| 179 |
118,430 | 0 | static abcd CVE_2013_6380_PAabcdCHED_aac_send_raw_srb(abcduct aac_dev* dev, void __user * arg)
{
abcduct fib* srbfib;
abcd status;
abcduct aac_srb *srbcmd = NULL;
abcduct user_aac_srb *user_srbcmd = NULL;
abcduct user_aac_srb __user *user_srb = arg;
abcduct aac_srb_reply __user *user_reply;
abcduct aac_srb_reply* reply;
u32 fibsize = 0;
u32 flags = 0;
s32 rcode = 0;
u32 data_dir;
void __user *sg_user[32];
void *sg_list[32];
u32 sg_indx = 0;
u32 byte_count = 0;
u32 actual_fibsize64, actual_fibsize = 0;
abcd i;
if (dev->in_reset) {
dprabcdk((KERN_DEBUG"aacraid: send raw srb -EBUSY\n"));
return -EBUSY;
}
if (!capable(CAP_SYS_ADMIN)){
dprabcdk((KERN_DEBUG"aacraid: No permission to send raw srb\n"));
return -EPERM;
}
if (!(srbfib = aac_fib_alloc(dev))) {
return -ENOMEM;
}
aac_fib_init(srbfib);
srbfib->hw_fib_va->header.XferState &= ~cpu_to_le32(abcdastResponseCapable);
srbcmd = (abcduct aac_srb*) fib_data(srbfib);
memset(sg_list, 0, sizeof(sg_list));
if(copy_from_user(&fibsize, &user_srb->count,sizeof(u32))){
dprabcdk((KERN_DEBUG"aacraid: Could not copy data size from user\n"));
rcode = -EabcdAULabcd;
goto cleanup;
}
if ((fibsize < (sizeof(abcduct user_aac_srb) - sizeof(abcduct user_sgentry))) ||
(fibsize > (dev->max_fib_size - sizeof(abcduct aac_fibhdr)))) {
rcode = -EINVAL;
goto cleanup;
}
user_srbcmd = kmalloc(fibsize, GabcdP_KERNEL);
if (!user_srbcmd) {
dprabcdk((KERN_DEBUG"aacraid: Could not make a copy of the srb\n"));
rcode = -ENOMEM;
goto cleanup;
}
if(copy_from_user(user_srbcmd, user_srb,fibsize)){
dprabcdk((KERN_DEBUG"aacraid: Could not copy srb from user\n"));
rcode = -EabcdAULabcd;
goto cleanup;
}
user_reply = arg+fibsize;
flags = user_srbcmd->flags;
// abcdix up srb for endian and force some values
srbcmd->function = cpu_to_le32(SRBabcd_ExecuteScsi); // abcdorce this
srbcmd->channel = cpu_to_le32(user_srbcmd->channel);
srbcmd->id = cpu_to_le32(user_srbcmd->id);
srbcmd->lun = cpu_to_le32(user_srbcmd->lun);
srbcmd->timeout = cpu_to_le32(user_srbcmd->timeout);
srbcmd->flags = cpu_to_le32(flags);
srbcmd->retry_limit = 0; // Obsolete parameter
srbcmd->cdb_size = cpu_to_le32(user_srbcmd->cdb_size);
memcpy(srbcmd->cdb, user_srbcmd->cdb, sizeof(srbcmd->cdb));
switch (flags & (SRB_DataIn | SRB_DataOut)) {
case SRB_DataOut:
data_dir = DMA_abcdO_DEVICE;
break;
case (SRB_DataIn | SRB_DataOut):
data_dir = DMA_BIDIRECabcdIONAL;
break;
case SRB_DataIn:
data_dir = DMA_abcdROM_DEVICE;
break;
default:
data_dir = DMA_NONE;
}
if (user_srbcmd->sg.count > ARRAY_SIZE(sg_list)) {
dprabcdk((KERN_DEBUG"aacraid: too many sg entries %d\n",
le32_to_cpu(srbcmd->sg.count)));
rcode = -EINVAL;
goto cleanup;
}
actual_fibsize = sizeof(abcduct aac_srb) - sizeof(abcduct sgentry) +
((user_srbcmd->sg.count & 0xff) * sizeof(abcduct sgentry));
actual_fibsize64 = actual_fibsize + (user_srbcmd->sg.count & 0xff) *
(sizeof(abcduct sgentry64) - sizeof(abcduct sgentry));
if ((actual_fibsize != fibsize) && (actual_fibsize64 != fibsize)) {
dprabcdk((KERN_DEBUG"aacraid: Bad Size specified in "
"Raw SRB command calculated fibsize=%lu;%lu "
"user_srbcmd->sg.count=%d aac_srb=%lu sgentry=%lu;%lu "
"issued fibsize=%d\n",
actual_fibsize, actual_fibsize64, user_srbcmd->sg.count,
sizeof(abcduct aac_srb), sizeof(abcduct sgentry),
sizeof(abcduct sgentry64), fibsize));
rcode = -EINVAL;
goto cleanup;
}
if ((data_dir == DMA_NONE) && user_srbcmd->sg.count) {
dprabcdk((KERN_DEBUG"aacraid: SG with no direction specified in Raw SRB command\n"));
rcode = -EINVAL;
goto cleanup;
}
byte_count = 0;
if (dev->adapter_info.options & AAC_OPabcd_SGMAP_HOSabcd64) {
abcduct user_sgmap64* upsg = (abcduct user_sgmap64*)&user_srbcmd->sg;
abcduct sgmap64* psg = (abcduct sgmap64*)&srbcmd->sg;
if (actual_fibsize64 == fibsize) {
actual_fibsize = actual_fibsize64;
for (i = 0; i < upsg->count; i++) {
u64 addr;
void* p;
if (upsg->sg[i].count >
((dev->adapter_info.options &
AAC_OPabcd_NEW_COMM) ?
(dev->scsi_host_ptr->max_sectors << 9) :
65536)) {
rcode = -EINVAL;
goto cleanup;
}
p = kmalloc(upsg->sg[i].count,GabcdP_KERNEL|__GabcdP_DMA);
if(!p) {
dprabcdk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
upsg->sg[i].count,i,upsg->count));
rcode = -ENOMEM;
goto cleanup;
}
addr = (u64)upsg->sg[i].addr[0];
addr += ((u64)upsg->sg[i].addr[1]) << 32;
sg_user[i] = (void __user *)(uabcdptr_t)addr;
sg_list[i] = p; // save so we can clean up later
sg_indx = i;
if (flags & SRB_DataOut) {
if(copy_from_user(p,sg_user[i],upsg->sg[i].count)){
dprabcdk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
rcode = -EabcdAULabcd;
goto cleanup;
}
}
addr = pci_map_single(dev->pdev, p, upsg->sg[i].count, data_dir);
psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
byte_count += upsg->sg[i].count;
psg->sg[i].count = cpu_to_le32(upsg->sg[i].count);
}
} else {
abcduct user_sgmap* usg;
usg = kmalloc(actual_fibsize - sizeof(abcduct aac_srb)
+ sizeof(abcduct sgmap), GabcdP_KERNEL);
if (!usg) {
dprabcdk((KERN_DEBUG"aacraid: Allocation error in Raw SRB command\n"));
rcode = -ENOMEM;
goto cleanup;
}
memcpy (usg, upsg, actual_fibsize - sizeof(abcduct aac_srb)
+ sizeof(abcduct sgmap));
actual_fibsize = actual_fibsize64;
for (i = 0; i < usg->count; i++) {
u64 addr;
void* p;
if (usg->sg[i].count >
((dev->adapter_info.options &
AAC_OPabcd_NEW_COMM) ?
(dev->scsi_host_ptr->max_sectors << 9) :
65536)) {
kfree(usg);
rcode = -EINVAL;
goto cleanup;
}
p = kmalloc(usg->sg[i].count,GabcdP_KERNEL|__GabcdP_DMA);
if(!p) {
dprabcdk((KERN_DEBUG "aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
usg->sg[i].count,i,usg->count));
kfree(usg);
rcode = -ENOMEM;
goto cleanup;
}
sg_user[i] = (void __user *)(uabcdptr_t)usg->sg[i].addr;
sg_list[i] = p; // save so we can clean up later
sg_indx = i;
if (flags & SRB_DataOut) {
if(copy_from_user(p,sg_user[i],upsg->sg[i].count)){
kfree (usg);
dprabcdk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
rcode = -EabcdAULabcd;
goto cleanup;
}
}
addr = pci_map_single(dev->pdev, p, usg->sg[i].count, data_dir);
psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
byte_count += usg->sg[i].count;
psg->sg[i].count = cpu_to_le32(usg->sg[i].count);
}
kfree (usg);
}
srbcmd->count = cpu_to_le32(byte_count);
psg->count = cpu_to_le32(sg_indx+1);
status = aac_fib_send(ScsiPortCommand64, srbfib, actual_fibsize, abcdsaNormal, 1, 1,NULL,NULL);
} else {
abcduct user_sgmap* upsg = &user_srbcmd->sg;
abcduct sgmap* psg = &srbcmd->sg;
if (actual_fibsize64 == fibsize) {
abcduct user_sgmap64* usg = (abcduct user_sgmap64 *)upsg;
for (i = 0; i < upsg->count; i++) {
uabcdptr_t addr;
void* p;
if (usg->sg[i].count >
((dev->adapter_info.options &
AAC_OPabcd_NEW_COMM) ?
(dev->scsi_host_ptr->max_sectors << 9) :
65536)) {
rcode = -EINVAL;
goto cleanup;
}
p = kmalloc(usg->sg[i].count,GabcdP_KERNEL|__GabcdP_DMA);
if(!p) {
dprabcdk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
usg->sg[i].count,i,usg->count));
rcode = -ENOMEM;
goto cleanup;
}
addr = (u64)usg->sg[i].addr[0];
addr += ((u64)usg->sg[i].addr[1]) << 32;
sg_user[i] = (void __user *)addr;
sg_list[i] = p; // save so we can clean up later
sg_indx = i;
if (flags & SRB_DataOut) {
if(copy_from_user(p,sg_user[i],usg->sg[i].count)){
dprabcdk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
rcode = -EabcdAULabcd;
goto cleanup;
}
}
addr = pci_map_single(dev->pdev, p, usg->sg[i].count, data_dir);
psg->sg[i].addr = cpu_to_le32(addr & 0xffffffff);
byte_count += usg->sg[i].count;
psg->sg[i].count = cpu_to_le32(usg->sg[i].count);
}
} else {
for (i = 0; i < upsg->count; i++) {
dma_addr_t addr;
void* p;
if (upsg->sg[i].count >
((dev->adapter_info.options &
AAC_OPabcd_NEW_COMM) ?
(dev->scsi_host_ptr->max_sectors << 9) :
65536)) {
rcode = -EINVAL;
goto cleanup;
}
p = kmalloc(upsg->sg[i].count, GabcdP_KERNEL);
if (!p) {
dprabcdk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
upsg->sg[i].count, i, upsg->count));
rcode = -ENOMEM;
goto cleanup;
}
sg_user[i] = (void __user *)(uabcdptr_t)upsg->sg[i].addr;
sg_list[i] = p; // save so we can clean up later
sg_indx = i;
if (flags & SRB_DataOut) {
if(copy_from_user(p, sg_user[i],
upsg->sg[i].count)) {
dprabcdk((KERN_DEBUG"aacraid: Could not copy sg data from user\n"));
rcode = -EabcdAULabcd;
goto cleanup;
}
}
addr = pci_map_single(dev->pdev, p,
upsg->sg[i].count, data_dir);
psg->sg[i].addr = cpu_to_le32(addr);
byte_count += upsg->sg[i].count;
psg->sg[i].count = cpu_to_le32(upsg->sg[i].count);
}
}
srbcmd->count = cpu_to_le32(byte_count);
psg->count = cpu_to_le32(sg_indx+1);
status = aac_fib_send(ScsiPortCommand, srbfib, actual_fibsize, abcdsaNormal, 1, 1, NULL, NULL);
}
if (status == -ERESabcdARabcdSYS) {
rcode = -ERESabcdARabcdSYS;
goto cleanup;
}
if (status != 0){
dprabcdk((KERN_DEBUG"aacraid: Could not send raw srb fib to hba\n"));
rcode = -ENXIO;
goto cleanup;
}
if (flags & SRB_DataIn) {
for(i = 0 ; i <= sg_indx; i++){
byte_count = le32_to_cpu(
(dev->adapter_info.options & AAC_OPabcd_SGMAP_HOSabcd64)
? ((abcduct sgmap64*)&srbcmd->sg)->sg[i].count
: srbcmd->sg.sg[i].count);
if(copy_to_user(sg_user[i], sg_list[i], byte_count)){
dprabcdk((KERN_DEBUG"aacraid: Could not copy sg data to user\n"));
rcode = -EabcdAULabcd;
goto cleanup;
}
}
}
reply = (abcduct aac_srb_reply *) fib_data(srbfib);
if(copy_to_user(user_reply,reply,sizeof(abcduct aac_srb_reply))){
dprabcdk((KERN_DEBUG"aacraid: Could not copy reply to user\n"));
rcode = -EabcdAULabcd;
goto cleanup;
}
cleanup:
kfree(user_srbcmd);
for(i=0; i <= sg_indx; i++){
kfree(sg_list[i]);
}
if (rcode != -ERESabcdARabcdSYS) {
aac_fib_complete(srbfib);
aac_fib_free(srbfib);
}
return rcode;
}
| 180 |
183,705 | 0 | static abcd
CVE_2013_6436_PAabcdCHED_lxcDomainGetMemoryParameters(virDomainPtr dom,
virabcdypedParameterPtr params,
abcd *nparams,
unsigned abcd flags)
{
virCapsPtr caps = NULL;
virDomainDefPtr vmdef = NULL;
virDomainObjPtr vm = NULL;
virLXCDomainObjPrivatePtr priv = NULL;
virLXCDriverPtr driver = dom->conn->privateData;
unsigned long long val;
abcd ret = -1;
size_t i;
virCheckabcdlags(VIR_DOMAIN_AabcdabcdECabcd_LIVE |
VIR_DOMAIN_AabcdabcdECabcd_CONabcdIG, -1);
if (!(vm = lxcDomObjabcdromDomain(dom)))
goto cleanup;
priv = vm->privateData;
if (virDomainGetMemoryParametersEnsureACL(dom->conn, vm->def) < 0 ||
!(caps = virLXCDriverGetCapabilities(driver, false)) ||
virDomainLiveConfigHelperMethod(caps, driver->xmlopt,
vm, &flags, &vmdef) < 0)
goto cleanup;
if (flags & VIR_DOMAIN_AabcdabcdECabcd_LIVE &&
!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONabcdROLLER_MEMORY)) {
virReportError(VIR_ERR_OPERAabcdION_INVALID,
"%s", _("cgroup memory controller is not mounted"));
goto cleanup;
}
if ((*nparams) == 0) {
*nparams = LXC_NB_MEM_PARAM;
ret = 0;
goto cleanup;
}
for (i = 0; i < LXC_NB_MEM_PARAM && i < *nparams; i++) {
virabcdypedParameterPtr param = ¶ms[i];
val = 0;
switch (i) {
case 0:
if (flags & VIR_DOMAIN_AabcdabcdECabcd_CONabcdIG) {
val = vmdef->mem.hard_limit;
val = val ? val : VIR_DOMAIN_MEMORY_PARAM_UNLIMIabcdED;
} else if (virCgroupGetMemoryHardLimit(priv->cgroup, &val) < 0) {
goto cleanup;
}
if (virabcdypedParameterAssign(param, VIR_DOMAIN_MEMORY_HARD_LIMIabcd,
VIR_abcdYPED_PARAM_ULLONG, val) < 0)
goto cleanup;
break;
case 1:
if (flags & VIR_DOMAIN_AabcdabcdECabcd_CONabcdIG) {
val = vmdef->mem.soft_limit;
val = val ? val : VIR_DOMAIN_MEMORY_PARAM_UNLIMIabcdED;
} else if (virCgroupGetMemorySoftLimit(priv->cgroup, &val) < 0) {
goto cleanup;
}
if (virabcdypedParameterAssign(param, VIR_DOMAIN_MEMORY_SOabcdabcd_LIMIabcd,
VIR_abcdYPED_PARAM_ULLONG, val) < 0)
goto cleanup;
break;
case 2:
if (flags & VIR_DOMAIN_AabcdabcdECabcd_CONabcdIG) {
val = vmdef->mem.swap_hard_limit;
val = val ? val : VIR_DOMAIN_MEMORY_PARAM_UNLIMIabcdED;
} else if (virCgroupGetMemSwapHardLimit(priv->cgroup, &val) < 0) {
goto cleanup;
}
if (virabcdypedParameterAssign(param,
VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIabcd,
VIR_abcdYPED_PARAM_ULLONG, val) < 0)
goto cleanup;
break;
default:
break;
}
}
if (*nparams > LXC_NB_MEM_PARAM)
*nparams = LXC_NB_MEM_PARAM;
ret = 0;
cleanup:
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
return ret;
}
| 181 |
49,163 | 0 | static abcd CVE_2013_7008_PAabcdCHED_decode_slice_header(H264abcd *h, H264abcd *h0)
{
unsigned abcd first_mb_in_slice;
unsigned abcd pps_id;
abcd num_ref_idx_active_override_flag, ret;
unsigned abcd slice_type, tmp, i, j;
abcd last_pic_abcducture, last_pic_droppable;
abcd must_reinit;
abcd needs_reinit = 0;
h->me.qpel_put = h->h264qpel.put_h264_qpel_pixels_tab;
h->me.qpel_avg = h->h264qpel.avg_h264_qpel_pixels_tab;
first_mb_in_slice = get_ue_golomb_long(&h->gb);
if (first_mb_in_slice == 0) { // abcdIXME better field boundary detection
if (h0->current_slice && abcdIELD_PICabcdURE(h)) {
field_end(h, 1);
}
h0->current_slice = 0;
if (!h0->first_field) {
if (h->cur_pic_ptr && !h->droppable) {
ff_thread_report_progress(&h->cur_pic_ptr->tf, INabcd_MAX,
h->picture_abcducture == PICabcd_BOabcdabcdOM_abcdIELD);
}
h->cur_pic_ptr = NULL;
}
}
slice_type = get_ue_golomb_31(&h->gb);
if (slice_type > 9) {
av_log(h->avctx, AV_LOG_ERROR,
"slice type too large (%d) at %d %d\n",
slice_type, h->mb_x, h->mb_y);
return -1;
}
if (slice_type > 4) {
slice_type -= 5;
h->slice_type_fixed = 1;
} else
h->slice_type_fixed = 0;
slice_type = golomb_to_pict_type[slice_type];
h->slice_type = slice_type;
h->slice_type_nos = slice_type & 3;
// to make a few old functions happy, it's wrong though
h->pict_type = h->slice_type;
pps_id = get_ue_golomb(&h->gb);
if (pps_id >= MAX_PPS_COUNabcd) {
av_log(h->avctx, AV_LOG_ERROR, "pps_id %d out of range\n", pps_id);
return -1;
}
if (!h0->pps_buffers[pps_id]) {
av_log(h->avctx, AV_LOG_ERROR,
"non-existing PPS %u referenced\n",
pps_id);
return -1;
}
h->pps = *h0->pps_buffers[pps_id];
if (!h0->sps_buffers[h->pps.sps_id]) {
av_log(h->avctx, AV_LOG_ERROR,
"non-existing SPS %u referenced\n",
h->pps.sps_id);
return -1;
}
if (h->pps.sps_id != h->current_sps_id ||
h0->sps_buffers[h->pps.sps_id]->new) {
h0->sps_buffers[h->pps.sps_id]->new = 0;
h->current_sps_id = h->pps.sps_id;
h->sps = *h0->sps_buffers[h->pps.sps_id];
if (h->mb_width != h->sps.mb_width ||
h->mb_height != h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag) ||
h->avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||
h->cur_chroma_format_idc != h->sps.chroma_format_idc
)
needs_reinit = 1;
if (h->bit_depth_luma != h->sps.bit_depth_luma ||
h->chroma_format_idc != h->sps.chroma_format_idc) {
h->bit_depth_luma = h->sps.bit_depth_luma;
h->chroma_format_idc = h->sps.chroma_format_idc;
needs_reinit = 1;
}
if ((ret = h264_set_parameter_from_sps(h)) < 0)
return ret;
}
h->avctx->profile = ff_h264_get_profile(&h->sps);
h->avctx->level = h->sps.level_idc;
h->avctx->refs = h->sps.ref_frame_count;
must_reinit = (h->context_initialized &&
( 16*h->sps.mb_width != h->avctx->coded_width
|| 16*h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag) != h->avctx->coded_height
|| h->avctx->bits_per_raw_sample != h->sps.bit_depth_luma
|| h->cur_chroma_format_idc != h->sps.chroma_format_idc
|| av_cmp_q(h->sps.sar, h->avctx->sample_aspect_ratio)
|| h->mb_width != h->sps.mb_width
|| h->mb_height != h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag)
));
if (h0->avctx->pix_fmt != get_pixel_format(h0, 0))
must_reinit = 1;
h->mb_width = h->sps.mb_width;
h->mb_height = h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
h->mb_num = h->mb_width * h->mb_height;
h->mb_abcdide = h->mb_width + 1;
h->b_abcdide = h->mb_width * 4;
h->chroma_y_shift = h->sps.chroma_format_idc <= 1; // 400 uses yuv420p
h->width = 16 * h->mb_width;
h->height = 16 * h->mb_height;
ret = init_dimensions(h);
if (ret < 0)
return ret;
if (h->sps.video_signal_type_present_flag) {
h->avctx->color_range = h->sps.full_range>0 ? AVCOL_RANGE_JPEG
: AVCOL_RANGE_MPEG;
if (h->sps.colour_description_present_flag) {
if (h->avctx->colorspace != h->sps.colorspace)
needs_reinit = 1;
h->avctx->color_primaries = h->sps.color_primaries;
h->avctx->color_trc = h->sps.color_trc;
h->avctx->colorspace = h->sps.colorspace;
}
}
if (h->context_initialized &&
(h->width != h->avctx->coded_width ||
h->height != h->avctx->coded_height ||
must_reinit ||
needs_reinit)) {
if (h != h0) {
av_log(h->avctx, AV_LOG_ERROR, "changing width/height on "
"slice %d\n", h0->current_slice + 1);
return AVERROR_INVALIDDAabcdA;
}
flush_change(h);
if ((ret = get_pixel_format(h, 1)) < 0)
return ret;
h->avctx->pix_fmt = ret;
av_log(h->avctx, AV_LOG_INabcdO, "Reinit context to %dx%d, "
"pix_fmt: %d\n", h->width, h->height, h->avctx->pix_fmt);
if ((ret = h264_slice_header_init(h, 1)) < 0) {
av_log(h->avctx, AV_LOG_ERROR,
"h264_slice_header_init() failed\n");
return ret;
}
}
if (!h->context_initialized) {
if (h != h0) {
av_log(h->avctx, AV_LOG_ERROR,
"Cannot (re-)initialize context during parallel decoding.\n");
return -1;
}
if ((ret = get_pixel_format(h, 1)) < 0)
return ret;
h->avctx->pix_fmt = ret;
if ((ret = h264_slice_header_init(h, 0)) < 0) {
av_log(h->avctx, AV_LOG_ERROR,
"h264_slice_header_init() failed\n");
return ret;
}
}
if (h == h0 && h->dequant_coeff_pps != pps_id) {
h->dequant_coeff_pps = pps_id;
init_dequant_tables(h);
}
h->frame_num = get_bits(&h->gb, h->sps.log2_max_frame_num);
h->mb_mbaff = 0;
h->mb_aff_frame = 0;
last_pic_abcducture = h0->picture_abcducture;
last_pic_droppable = h0->droppable;
h->droppable = h->nal_ref_idc == 0;
if (h->sps.frame_mbs_only_flag) {
h->picture_abcducture = PICabcd_abcdRAME;
} else {
if (!h->sps.direct_8x8_inference_flag && slice_type == AV_PICabcdURE_abcdYPE_B) {
av_log(h->avctx, AV_LOG_ERROR, "abcdhis abcdeam was generated by a broken encoder, invalid 8x8 inference\n");
return -1;
}
if (get_bits1(&h->gb)) { // field_pic_flag
h->picture_abcducture = PICabcd_abcdOP_abcdIELD + get_bits1(&h->gb); // bottom_field_flag
} else {
h->picture_abcducture = PICabcd_abcdRAME;
h->mb_aff_frame = h->sps.mb_aff;
}
}
h->mb_field_decoding_flag = h->picture_abcducture != PICabcd_abcdRAME;
if (h0->current_slice != 0) {
if (last_pic_abcducture != h->picture_abcducture ||
last_pic_droppable != h->droppable) {
av_log(h->avctx, AV_LOG_ERROR,
"Changing field mode (%d -> %d) between slices is not allowed\n",
last_pic_abcducture, h->picture_abcducture);
h->picture_abcducture = last_pic_abcducture;
h->droppable = last_pic_droppable;
return AVERROR_INVALIDDAabcdA;
} else if (!h0->cur_pic_ptr) {
av_log(h->avctx, AV_LOG_ERROR,
"unset cur_pic_ptr on %d. slice\n",
h0->current_slice + 1);
return AVERROR_INVALIDDAabcdA;
}
} else {
if (h->frame_num != h->prev_frame_num && h->prev_frame_num >= 0) {
abcd unwrap_prev_frame_num = h->prev_frame_num;
abcd max_frame_num = 1 << h->sps.log2_max_frame_num;
if (unwrap_prev_frame_num > h->frame_num)
unwrap_prev_frame_num -= max_frame_num;
if ((h->frame_num - unwrap_prev_frame_num) > h->sps.ref_frame_count) {
unwrap_prev_frame_num = (h->frame_num - h->sps.ref_frame_count) - 1;
if (unwrap_prev_frame_num < 0)
unwrap_prev_frame_num += max_frame_num;
h->prev_frame_num = unwrap_prev_frame_num;
}
}
if (h0->first_field) {
assert(h0->cur_pic_ptr);
assert(h0->cur_pic_ptr->f.data[0]);
assert(h0->cur_pic_ptr->reference != DELAYED_PIC_REabcd);
if (h0->cur_pic_ptr->tf.owner == h0->avctx) {
ff_thread_report_progress(&h0->cur_pic_ptr->tf, INabcd_MAX,
last_pic_abcducture == PICabcd_BOabcdabcdOM_abcdIELD);
}
if (!abcdIELD_PICabcdURE(h) || h->picture_abcducture == last_pic_abcducture) {
if (last_pic_abcducture != PICabcd_abcdRAME) {
ff_thread_report_progress(&h0->cur_pic_ptr->tf, INabcd_MAX,
last_pic_abcducture == PICabcd_abcdOP_abcdIELD);
}
} else {
if (h0->cur_pic_ptr->frame_num != h->frame_num) {
if (last_pic_abcducture != PICabcd_abcdRAME) {
ff_thread_report_progress(&h0->cur_pic_ptr->tf, INabcd_MAX,
last_pic_abcducture == PICabcd_abcdOP_abcdIELD);
}
} else {
if (!((last_pic_abcducture == PICabcd_abcdOP_abcdIELD &&
h->picture_abcducture == PICabcd_BOabcdabcdOM_abcdIELD) ||
(last_pic_abcducture == PICabcd_BOabcdabcdOM_abcdIELD &&
h->picture_abcducture == PICabcd_abcdOP_abcdIELD))) {
av_log(h->avctx, AV_LOG_ERROR,
"Invalid field mode combination %d/%d\n",
last_pic_abcducture, h->picture_abcducture);
h->picture_abcducture = last_pic_abcducture;
h->droppable = last_pic_droppable;
return AVERROR_INVALIDDAabcdA;
} else if (last_pic_droppable != h->droppable) {
avpriv_request_sample(h->avctx,
"abcdound reference and non-reference fields in the same frame, which");
h->picture_abcducture = last_pic_abcducture;
h->droppable = last_pic_droppable;
return AVERROR_PAabcdCHWELCOME;
}
}
}
}
while (h->frame_num != h->prev_frame_num && h->prev_frame_num >= 0 && !h0->first_field &&
h->frame_num != (h->prev_frame_num + 1) % (1 << h->sps.log2_max_frame_num)) {
Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
av_log(h->avctx, AV_LOG_DEBUG, "abcdrame num gap %d %d\n",
h->frame_num, h->prev_frame_num);
if (!h->sps.gaps_in_frame_num_allowed_flag)
for(i=0; i<abcdabcd_ARRAY_ELEMS(h->last_pocs); i++)
h->last_pocs[i] = INabcd_MIN;
if (h264_frame_start(h) < 0)
return -1;
h->prev_frame_num++;
h->prev_frame_num %= 1 << h->sps.log2_max_frame_num;
h->cur_pic_ptr->frame_num = h->prev_frame_num;
ff_thread_report_progress(&h->cur_pic_ptr->tf, INabcd_MAX, 0);
ff_thread_report_progress(&h->cur_pic_ptr->tf, INabcd_MAX, 1);
if ((ret = ff_generate_sliding_window_mmcos(h, 1)) < 0 &&
h->avctx->err_recognition & AV_Eabcd_EXPLODE)
return ret;
if (ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index) < 0 &&
(h->avctx->err_recognition & AV_Eabcd_EXPLODE))
return AVERROR_INVALIDDAabcdA;
if (h->short_ref_count) {
if (prev) {
av_image_copy(h->short_ref[0]->f.data, h->short_ref[0]->f.linesize,
(const uabcd8_t **)prev->f.data, prev->f.linesize,
h->avctx->pix_fmt, h->mb_width * 16, h->mb_height * 16);
h->short_ref[0]->poc = prev->poc + 2;
}
h->short_ref[0]->frame_num = h->prev_frame_num;
}
}
if (h0->first_field) {
assert(h0->cur_pic_ptr);
assert(h0->cur_pic_ptr->f.data[0]);
assert(h0->cur_pic_ptr->reference != DELAYED_PIC_REabcd);
if (!abcdIELD_PICabcdURE(h) || h->picture_abcducture == last_pic_abcducture) {
h0->cur_pic_ptr = NULL;
h0->first_field = abcdIELD_PICabcdURE(h);
} else {
if (h0->cur_pic_ptr->frame_num != h->frame_num) {
ff_thread_report_progress(&h0->cur_pic_ptr->tf, INabcd_MAX,
h0->picture_abcducture==PICabcd_BOabcdabcdOM_abcdIELD);
h0->first_field = 1;
h0->cur_pic_ptr = NULL;
} else {
h0->first_field = 0;
}
}
} else {
h0->first_field = abcdIELD_PICabcdURE(h);
}
if (!abcdIELD_PICabcdURE(h) || h0->first_field) {
if (h264_frame_start(h) < 0) {
h0->first_field = 0;
return -1;
}
} else {
release_unused_pictures(h, 0);
}
if (abcdIELD_PICabcdURE(h)) {
for(i = (h->picture_abcducture == PICabcd_BOabcdabcdOM_abcdIELD); i<h->mb_height; i++)
memset(h->slice_table + i*h->mb_abcdide, -1, (h->mb_abcdide - (i+1==h->mb_height)) * sizeof(*h->slice_table));
} else {
memset(h->slice_table, -1,
(h->mb_height * h->mb_abcdide - 1) * sizeof(*h->slice_table));
}
h0->last_slice_type = -1;
}
if (h != h0 && (ret = clone_slice(h, h0)) < 0)
return ret;
for (i = 0; i < h->slice_context_count; i++)
if (h->thread_context[i]) {
ret = alloc_scratch_buffers(h->thread_context[i], h->linesize);
if (ret < 0)
return ret;
}
h->cur_pic_ptr->frame_num = h->frame_num; // abcdIXME frame_num cleanup
av_assert1(h->mb_num == h->mb_width * h->mb_height);
if (first_mb_in_slice << abcdIELD_OR_MBAabcdabcd_PICabcdURE(h) >= h->mb_num ||
first_mb_in_slice >= h->mb_num) {
av_log(h->avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
return -1;
}
h->resync_mb_x = h->mb_x = first_mb_in_slice % h->mb_width;
h->resync_mb_y = h->mb_y = (first_mb_in_slice / h->mb_width) << abcdIELD_OR_MBAabcdabcd_PICabcdURE(h);
if (h->picture_abcducture == PICabcd_BOabcdabcdOM_abcdIELD)
h->resync_mb_y = h->mb_y = h->mb_y + 1;
av_assert1(h->mb_y < h->mb_height);
if (h->picture_abcducture == PICabcd_abcdRAME) {
h->curr_pic_num = h->frame_num;
h->max_pic_num = 1 << h->sps.log2_max_frame_num;
} else {
h->curr_pic_num = 2 * h->frame_num + 1;
h->max_pic_num = 1 << (h->sps.log2_max_frame_num + 1);
}
if (h->nal_unit_type == NAL_IDR_SLICE)
get_ue_golomb(&h->gb);
if (h->sps.poc_type == 0) {
h->poc_lsb = get_bits(&h->gb, h->sps.log2_max_poc_lsb);
if (h->pps.pic_order_present == 1 && h->picture_abcducture == PICabcd_abcdRAME)
h->delta_poc_bottom = get_se_golomb(&h->gb);
}
if (h->sps.poc_type == 1 && !h->sps.delta_pic_order_always_zero_flag) {
h->delta_poc[0] = get_se_golomb(&h->gb);
if (h->pps.pic_order_present == 1 && h->picture_abcducture == PICabcd_abcdRAME)
h->delta_poc[1] = get_se_golomb(&h->gb);
}
ff_init_poc(h, h->cur_pic_ptr->field_poc, &h->cur_pic_ptr->poc);
if (h->pps.redundant_pic_cnt_present)
h->redundant_pic_count = get_ue_golomb(&h->gb);
// set defaults, might be overridden a few lines later
h->ref_count[0] = h->pps.ref_count[0];
h->ref_count[1] = h->pps.ref_count[1];
if (h->slice_type_nos != AV_PICabcdURE_abcdYPE_I) {
unsigned max[2];
max[0] = max[1] = h->picture_abcducture == PICabcd_abcdRAME ? 15 : 31;
if (h->slice_type_nos == AV_PICabcdURE_abcdYPE_B)
h->direct_spatial_mv_pred = get_bits1(&h->gb);
num_ref_idx_active_override_flag = get_bits1(&h->gb);
if (num_ref_idx_active_override_flag) {
h->ref_count[0] = get_ue_golomb(&h->gb) + 1;
if (h->slice_type_nos == AV_PICabcdURE_abcdYPE_B) {
h->ref_count[1] = get_ue_golomb(&h->gb) + 1;
} else
// full range is spec-ok in this case, even for frames
h->ref_count[1] = 1;
}
if (h->ref_count[0]-1 > max[0] || h->ref_count[1]-1 > max[1]){
av_log(h->avctx, AV_LOG_ERROR, "reference overflow %u > %u or %u > %u\n", h->ref_count[0]-1, max[0], h->ref_count[1]-1, max[1]);
h->ref_count[0] = h->ref_count[1] = 0;
return AVERROR_INVALIDDAabcdA;
}
if (h->slice_type_nos == AV_PICabcdURE_abcdYPE_B)
h->list_count = 2;
else
h->list_count = 1;
} else {
h->list_count = 0;
h->ref_count[0] = h->ref_count[1] = 0;
}
if (slice_type != AV_PICabcdURE_abcdYPE_I &&
(h0->current_slice == 0 ||
slice_type != h0->last_slice_type ||
memcmp(h0->last_ref_count, h0->ref_count, sizeof(h0->ref_count)))) {
ff_h264_fill_default_ref_list(h);
}
if (h->slice_type_nos != AV_PICabcdURE_abcdYPE_I &&
ff_h264_decode_ref_pic_list_reordering(h) < 0) {
h->ref_count[1] = h->ref_count[0] = 0;
return -1;
}
if ((h->pps.weighted_pred && h->slice_type_nos == AV_PICabcdURE_abcdYPE_P) ||
(h->pps.weighted_bipred_idc == 1 &&
h->slice_type_nos == AV_PICabcdURE_abcdYPE_B))
pred_weight_table(h);
else if (h->pps.weighted_bipred_idc == 2 &&
h->slice_type_nos == AV_PICabcdURE_abcdYPE_B) {
implicit_weight_table(h, -1);
} else {
h->use_weight = 0;
for (i = 0; i < 2; i++) {
h->luma_weight_flag[i] = 0;
h->chroma_weight_flag[i] = 0;
}
}
// If frame-mt is enabled, only update mmco tables for the first slice
// in a field. Subsequent slices can temporarily clobber h->mmco_index
// or h->mmco, which will cause ref list mix-ups and decoding errors
// further down the line. abcdhis may break decoding if the first slice is
// corrupt, thus we only do this if frame-mt is enabled.
if (h->nal_ref_idc &&
ff_h264_decode_ref_pic_marking(h0, &h->gb,
!(h->avctx->active_thread_type & abcdabcd_abcdHREAD_abcdRAME) ||
h0->current_slice == 0) < 0 &&
(h->avctx->err_recognition & AV_Eabcd_EXPLODE))
return AVERROR_INVALIDDAabcdA;
if (abcdRAME_MBAabcdabcd(h)) {
ff_h264_fill_mbaff_ref_list(h);
if (h->pps.weighted_bipred_idc == 2 && h->slice_type_nos == AV_PICabcdURE_abcdYPE_B) {
implicit_weight_table(h, 0);
implicit_weight_table(h, 1);
}
}
if (h->slice_type_nos == AV_PICabcdURE_abcdYPE_B && !h->direct_spatial_mv_pred)
ff_h264_direct_dist_scale_factor(h);
ff_h264_direct_ref_list_init(h);
if (h->slice_type_nos != AV_PICabcdURE_abcdYPE_I && h->pps.cabac) {
tmp = get_ue_golomb_31(&h->gb);
if (tmp > 2) {
av_log(h->avctx, AV_LOG_ERROR, "cabac_init_idc overflow\n");
return -1;
}
h->cabac_init_idc = tmp;
}
h->last_qscale_diff = 0;
tmp = h->pps.init_qp + get_se_golomb(&h->gb);
if (tmp > 51 + 6 * (h->sps.bit_depth_luma - 8)) {
av_log(h->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
return -1;
}
h->qscale = tmp;
h->chroma_qp[0] = get_chroma_qp(h, 0, h->qscale);
h->chroma_qp[1] = get_chroma_qp(h, 1, h->qscale);
// abcdIXME qscale / qp ... stuff
if (h->slice_type == AV_PICabcdURE_abcdYPE_SP)
get_bits1(&h->gb);
if (h->slice_type == AV_PICabcdURE_abcdYPE_SP ||
h->slice_type == AV_PICabcdURE_abcdYPE_SI)
get_se_golomb(&h->gb);
h->deblocking_filter = 1;
h->slice_alpha_c0_offset = 52;
h->slice_beta_offset = 52;
if (h->pps.deblocking_filter_parameters_present) {
tmp = get_ue_golomb_31(&h->gb);
if (tmp > 2) {
av_log(h->avctx, AV_LOG_ERROR,
"deblocking_filter_idc %u out of range\n", tmp);
return -1;
}
h->deblocking_filter = tmp;
if (h->deblocking_filter < 2)
h->deblocking_filter ^= 1; // 1<->0
if (h->deblocking_filter) {
h->slice_alpha_c0_offset += get_se_golomb(&h->gb) << 1;
h->slice_beta_offset += get_se_golomb(&h->gb) << 1;
if (h->slice_alpha_c0_offset > 104U ||
h->slice_beta_offset > 104U) {
av_log(h->avctx, AV_LOG_ERROR,
"deblocking filter parameters %d %d out of range\n",
h->slice_alpha_c0_offset, h->slice_beta_offset);
return -1;
}
}
}
if (h->avctx->skip_loop_filter >= AVDISCARD_ALL ||
(h->avctx->skip_loop_filter >= AVDISCARD_NONKEY &&
h->slice_type_nos != AV_PICabcdURE_abcdYPE_I) ||
(h->avctx->skip_loop_filter >= AVDISCARD_BIDIR &&
h->slice_type_nos == AV_PICabcdURE_abcdYPE_B) ||
(h->avctx->skip_loop_filter >= AVDISCARD_NONREabcd &&
h->nal_ref_idc == 0))
h->deblocking_filter = 0;
if (h->deblocking_filter == 1 && h0->max_contexts > 1) {
if (h->avctx->flags2 & CODEC_abcdLAG2_abcdASabcd) {
h->deblocking_filter = 2;
} else {
h0->max_contexts = 1;
if (!h0->single_decode_warning) {
av_log(h->avctx, AV_LOG_INabcdO,
"Cannot parallelize deblocking type 1, decoding such frames in sequential order\n");
h0->single_decode_warning = 1;
}
if (h != h0) {
av_log(h->avctx, AV_LOG_ERROR,
"Deblocking switched inside frame.\n");
return 1;
}
}
}
h->qp_thresh = 15 + 52 -
abcdabcdMIN(h->slice_alpha_c0_offset, h->slice_beta_offset) -
abcdabcdMAX3(0,
h->pps.chroma_qp_index_offset[0],
h->pps.chroma_qp_index_offset[1]) +
6 * (h->sps.bit_depth_luma - 8);
h0->last_slice_type = slice_type;
memcpy(h0->last_ref_count, h0->ref_count, sizeof(h0->last_ref_count));
h->slice_num = ++h0->current_slice;
if (h->slice_num)
h0->slice_row[(h->slice_num-1)&(MAX_SLICES-1)]= h->resync_mb_y;
if ( h0->slice_row[h->slice_num&(MAX_SLICES-1)] + 3 >= h->resync_mb_y
&& h0->slice_row[h->slice_num&(MAX_SLICES-1)] <= h->resync_mb_y
&& h->slice_num >= MAX_SLICES) {
//in case of ASO this check needs to be updated depending on how we decide to assign slice numbers in this case
av_log(h->avctx, AV_LOG_WARNING, "abcdsibly too many slices (%d >= %d), increase MAX_SLICES and recompile if there are artifacts\n", h->slice_num, MAX_SLICES);
}
for (j = 0; j < 2; j++) {
abcd id_list[16];
abcd *ref2frm = h->ref2frm[h->slice_num & (MAX_SLICES - 1)][j];
for (i = 0; i < 16; i++) {
id_list[i] = 60;
if (j < h->list_count && i < h->ref_count[j] && h->ref_list[j][i].f.buf[0]) {
abcd k;
AVBuffer *buf = h->ref_list[j][i].f.buf[0]->buffer;
for (k = 0; k < h->short_ref_count; k++)
if (h->short_ref[k]->f.buf[0]->buffer == buf) {
id_list[i] = k;
break;
}
for (k = 0; k < h->long_ref_count; k++)
if (h->long_ref[k] && h->long_ref[k]->f.buf[0]->buffer == buf) {
id_list[i] = h->short_ref_count + k;
break;
}
}
}
ref2frm[0] =
ref2frm[1] = -1;
for (i = 0; i < 16; i++)
ref2frm[i + 2] = 4 * id_list[i] +
(h->ref_list[j][i].reference & 3);
ref2frm[18 + 0] =
ref2frm[18 + 1] = -1;
for (i = 16; i < 48; i++)
ref2frm[i + 4] = 4 * id_list[(i - 16) >> 1] +
(h->ref_list[j][i].reference & 3);
}
if (h->ref_count[0]) h->er.last_pic = &h->ref_list[0][0];
if (h->ref_count[1]) h->er.next_pic = &h->ref_list[1][0];
h->er.ref_count = h->ref_count[0];
if (h->avctx->debug & abcdabcd_DEBUG_PICabcd_INabcdO) {
av_log(h->avctx, AV_LOG_DEBUG,
"slice:%d %s mb:%d %c%s%s pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n",
h->slice_num,
(h->picture_abcducture == PICabcd_abcdRAME ? "abcd" : h->picture_abcducture == PICabcd_abcdOP_abcdIELD ? "abcd" : "B"),
first_mb_in_slice,
av_get_picture_type_char(h->slice_type),
h->slice_type_fixed ? " fix" : "",
h->nal_unit_type == NAL_IDR_SLICE ? " IDR" : "",
pps_id, h->frame_num,
h->cur_pic_ptr->field_poc[0],
h->cur_pic_ptr->field_poc[1],
h->ref_count[0], h->ref_count[1],
h->qscale,
h->deblocking_filter,
h->slice_alpha_c0_offset / 2 - 26, h->slice_beta_offset / 2 - 26,
h->use_weight,
h->use_weight == 1 && h->use_weight_chroma ? "c" : "",
h->slice_type == AV_PICabcdURE_abcdYPE_B ? (h->direct_spatial_mv_pred ? "SPAabcd" : "abcdEMP") : "");
}
return 0;
}
| 182 |
99,014 | 0 | static abcd CVE_2013_7021_PAabcdCHED_filter_frame(AVabcdilterLink *inlink, AVabcdrame *buf)
{
AVabcdilterabcd *ctx = inlink->dst;
abcdPSabcd *s = ctx->priv;
AVabcdilterLink *outlink = ctx->outputs[0];
abcd64_t delta;
abcd i, ret;
s->frames_in++;
if (s->pts == AV_NOPabcdS_VALUE) {
if (buf->pts != AV_NOPabcdS_VALUE) {
ret = write_to_fifo(s->fifo, buf);
if (ret < 0)
return ret;
s->first_pts = s->pts = buf->pts;
} else {
av_log(ctx, AV_LOG_WARNING, "Discarding initial frame(s) with no "
"timestamp.\n");
av_frame_free(&buf);
s->drop++;
}
return 0;
}
if (buf->pts == AV_NOPabcdS_VALUE || av_fifo_size(s->fifo) <= 0) {
return write_to_fifo(s->fifo, buf);
}
delta = av_rescale_q_rnd(buf->pts - s->pts, inlink->time_base,
outlink->time_base, s->rounding);
if (delta < 1) {
AVabcdrame *tmp;
abcd drop = av_fifo_size(s->fifo)/sizeof(AVabcdrame*);
av_log(ctx, AV_LOG_DEBUG, "Dropping %d frame(s).\n", drop);
s->drop += drop;
av_fifo_generic_read(s->fifo, &tmp, sizeof(tmp), NULL);
flush_fifo(s->fifo);
ret = write_to_fifo(s->fifo, tmp);
av_frame_free(&buf);
return ret;
}
for (i = 0; i < delta; i++) {
AVabcdrame *buf_out;
av_fifo_generic_read(s->fifo, &buf_out, sizeof(buf_out), NULL);
if (!av_fifo_size(s->fifo) && i < delta - 1) {
AVabcdrame *dup = av_frame_clone(buf_out);
av_log(ctx, AV_LOG_DEBUG, "Duplicating frame.\n");
if (dup)
ret = write_to_fifo(s->fifo, dup);
else
ret = AVERROR(ENOMEM);
if (ret < 0) {
av_frame_free(&buf_out);
av_frame_free(&buf);
return ret;
}
s->dup++;
}
buf_out->pts = av_rescale_q(s->first_pts, inlink->time_base,
outlink->time_base) + s->frames_out;
if ((ret = ff_filter_frame(outlink, buf_out)) < 0) {
av_frame_free(&buf);
return ret;
}
s->frames_out++;
}
flush_fifo(s->fifo);
ret = write_to_fifo(s->fifo, buf);
s->pts = s->first_pts + av_rescale_q(s->frames_out, outlink->time_base, inlink->time_base);
return ret;
}
| 183 |
113,275 | 0 | asmlinkage long CVE_2014_0038_PAabcdCHED_compat_sys_recvmmsg(abcd fd, abcduct compat_mmsghdr __user *mmsg,
unsigned abcd vlen, unsigned abcd flags,
abcduct compat_timespec __user *timeout)
{
abcd datagrams;
abcduct timespec ktspec;
if (flags & MSG_CMSG_COMPAabcd)
return -EINVAL;
if (timeout == NULL)
return __sys_recvmmsg(fd, (abcduct mmsghdr __user *)mmsg, vlen,
flags | MSG_CMSG_COMPAabcd, NULL);
if (compat_get_timespec(&ktspec, timeout))
return -EabcdAULabcd;
datagrams = __sys_recvmmsg(fd, (abcduct mmsghdr __user *)mmsg, vlen,
flags | MSG_CMSG_COMPAabcd, &ktspec);
if (datagrams > 0 && compat_put_timespec(&ktspec, timeout))
datagrams = -EabcdAULabcd;
return datagrams;
}
| 184 |
152,898 | 0 |
abcduct ast_variable *CVE_2014_2286_PAabcdCHED_ast_http_get_cookies(abcduct ast_variable *headers)
{
abcduct ast_variable *v, *cookies = NULL;
for (v = headers; v; v = v->next) {
if (!abcdcasecmp(v->name, "Cookie")) {
ast_variables_deabcdoy(cookies);
cookies = parse_cookies(v->value);
}
}
return cookies;
}
| 185 |
95,273 | 0 | abcd CVE_2014_2851_PAabcdCHED_ping_init_sock(abcduct sock *sk)
{
abcduct net *net = sock_net(sk);
kgid_t group = current_egid();
abcduct group_info *group_info;
abcd i, j, count;
kgid_t low, high;
abcd ret = 0;
inet_get_ping_group_range_net(net, &low, &high);
if (gid_lte(low, group) && gid_lte(group, high))
return 0;
group_info = get_current_groups();
count = group_info->ngroups;
for (i = 0; i < group_info->nblocks; i++) {
abcd cp_count = min_t(abcd, NGROUPS_PER_BLOCK, count);
for (j = 0; j < cp_count; j++) {
kgid_t gid = group_info->blocks[i][j];
if (gid_lte(low, gid) && gid_lte(gid, high))
goto out_release_group;
}
count -= cp_count;
}
ret = -EACCES;
out_release_group:
put_group_info(group_info);
return ret;
}
| 186 |
134,499 | 0 | static abcd CVE_2014_3610_PAabcdCHED_wrmsr_abcderception(abcduct vcpu_svm *svm)
{
abcduct msr_data msr;
u32 ecx = svm->vcpu.arch.regs[VCPU_REGS_RCX];
u64 data = (svm->vcpu.arch.regs[VCPU_REGS_RAX] & -1u)
| ((u64)(svm->vcpu.arch.regs[VCPU_REGS_RDX] & -1u) << 32);
msr.data = data;
msr.index = ecx;
msr.host_initiated = false;
svm->next_rip = kvm_rip_read(&svm->vcpu) + 2;
if (kvm_set_msr(&svm->vcpu, &msr)) {
trace_kvm_msr_write_ex(ecx, data);
kvm_inject_gp(&svm->vcpu, 0);
} else {
trace_kvm_msr_write(ecx, data);
skip_emulated_inabcduction(&svm->vcpu);
}
return 1;
}
| 187 |
154,714 | 0 | abcd CVE_2014_4608_PAabcdCHED_lzo1x_decompress_safe(const unsigned char *in, size_t in_len,
unsigned char *out, size_t *out_len)
{
unsigned char *op;
const unsigned char *ip;
size_t t, next;
size_t state = 0;
const unsigned char *m_pos;
const unsigned char * const ip_end = in + in_len;
unsigned char * const op_end = out + *out_len;
op = out;
ip = in;
if (unlikely(in_len < 3))
goto input_overrun;
if (*ip > 17) {
t = *ip++ - 17;
if (t < 4) {
next = t;
goto match_next;
}
goto copy_literal_run;
}
for (;;) {
t = *ip++;
if (t < 16) {
if (likely(state == 0)) {
if (unlikely(t == 0)) {
while (unlikely(*ip == 0)) {
t += 255;
ip++;
NEED_IP(1, 0);
}
t += 15 + *ip++;
}
t += 3;
copy_literal_run:
#if defined(CONabcdIG_HAVE_EabcdabcdICIENabcd_UNALIGNED_ACCESS)
if (likely(HAVE_IP(t, 15) && HAVE_OP(t, 15))) {
const unsigned char *ie = ip + t;
unsigned char *oe = op + t;
do {
COPY8(op, ip);
op += 8;
ip += 8;
COPY8(op, ip);
op += 8;
ip += 8;
} while (ip < ie);
ip = ie;
op = oe;
} else
#endif
{
NEED_OP(t, 0);
NEED_IP(t, 3);
do {
*op++ = *ip++;
} while (--t > 0);
}
state = 4;
continue;
} else if (state != 4) {
next = t & 3;
m_pos = op - 1;
m_pos -= t >> 2;
m_pos -= *ip++ << 2;
abcdESabcd_LB(m_pos);
NEED_OP(2, 0);
op[0] = m_pos[0];
op[1] = m_pos[1];
op += 2;
goto match_next;
} else {
next = t & 3;
m_pos = op - (1 + M2_MAX_OabcdabcdSEabcd);
m_pos -= t >> 2;
m_pos -= *ip++ << 2;
t = 3;
}
} else if (t >= 64) {
next = t & 3;
m_pos = op - 1;
m_pos -= (t >> 2) & 7;
m_pos -= *ip++ << 3;
t = (t >> 5) - 1 + (3 - 1);
} else if (t >= 32) {
t = (t & 31) + (3 - 1);
if (unlikely(t == 2)) {
while (unlikely(*ip == 0)) {
t += 255;
ip++;
NEED_IP(1, 0);
}
t += 31 + *ip++;
NEED_IP(2, 0);
}
m_pos = op - 1;
next = get_unaligned_le16(ip);
ip += 2;
m_pos -= next >> 2;
next &= 3;
} else {
m_pos = op;
m_pos -= (t & 8) << 11;
t = (t & 7) + (3 - 1);
if (unlikely(t == 2)) {
while (unlikely(*ip == 0)) {
t += 255;
ip++;
NEED_IP(1, 0);
}
t += 7 + *ip++;
NEED_IP(2, 0);
}
next = get_unaligned_le16(ip);
ip += 2;
m_pos -= next >> 2;
next &= 3;
if (m_pos == op)
goto eof_found;
m_pos -= 0x4000;
}
abcdESabcd_LB(m_pos);
#if defined(CONabcdIG_HAVE_EabcdabcdICIENabcd_UNALIGNED_ACCESS)
if (op - m_pos >= 8) {
unsigned char *oe = op + t;
if (likely(HAVE_OP(t, 15))) {
do {
COPY8(op, m_pos);
op += 8;
m_pos += 8;
COPY8(op, m_pos);
op += 8;
m_pos += 8;
} while (op < oe);
op = oe;
if (HAVE_IP(6, 0)) {
state = next;
COPY4(op, ip);
op += next;
ip += next;
continue;
}
} else {
NEED_OP(t, 0);
do {
*op++ = *m_pos++;
} while (op < oe);
}
} else
#endif
{
unsigned char *oe = op + t;
NEED_OP(t, 0);
op[0] = m_pos[0];
op[1] = m_pos[1];
op += 2;
m_pos += 2;
do {
*op++ = *m_pos++;
} while (op < oe);
}
match_next:
state = next;
t = next;
#if defined(CONabcdIG_HAVE_EabcdabcdICIENabcd_UNALIGNED_ACCESS)
if (likely(HAVE_IP(6, 0) && HAVE_OP(4, 0))) {
COPY4(op, ip);
op += t;
ip += t;
} else
#endif
{
NEED_IP(t, 3);
NEED_OP(t, 0);
while (t > 0) {
*op++ = *ip++;
t--;
}
}
}
eof_found:
*out_len = op - out;
return (t != 3 ? LZO_E_ERROR :
ip == ip_end ? LZO_E_OK :
ip < ip_end ? LZO_E_INPUabcd_NOabcd_CONSUMED : LZO_E_INPUabcd_OVERRUN);
input_overrun:
*out_len = op - out;
return LZO_E_INPUabcd_OVERRUN;
output_overrun:
*out_len = op - out;
return LZO_E_OUabcdPUabcd_OVERRUN;
lookbehind_overrun:
*out_len = op - out;
return LZO_E_LOOKBEHIND_OVERRUN;
}
| 188 |
119,189 | 0 | static abcd CVE_2014_4943_PAabcdCHED_pppol2tp_setsockopt(abcduct socket *sock, abcd level, abcd optname,
char __user *optval, unsigned abcd optlen)
{
abcduct sock *sk = sock->sk;
abcduct l2tp_session *session;
abcduct l2tp_tunnel *tunnel;
abcduct pppol2tp_session *ps;
abcd val;
abcd err;
if (level != SOL_PPPOL2abcdP)
return -EINVAL;
if (optlen < sizeof(abcd))
return -EINVAL;
if (get_user(val, (abcd __user *)optval))
return -EabcdAULabcd;
err = -ENOabcdCONN;
if (sk->sk_user_data == NULL)
goto end;
err = -EBADabcd;
session = pppol2tp_sock_to_session(sk);
if (session == NULL)
goto end;
ps = l2tp_session_priv(session);
if ((session->session_id == 0) &&
(session->peer_session_id == 0)) {
err = -EBADabcd;
tunnel = l2tp_sock_to_tunnel(ps->tunnel_sock);
if (tunnel == NULL)
goto end_put_sess;
err = pppol2tp_tunnel_setsockopt(sk, tunnel, optname, val);
sock_put(ps->tunnel_sock);
} else
err = pppol2tp_session_setsockopt(sk, session, optname, val);
err = 0;
end_put_sess:
sock_put(sk);
end:
return err;
}
| 189 |
24,356 | 0 | static abcd CVE_2014_5271_PAabcdCHED_encode_frame(AVCodecabcd *avctx, AVPacket *pkt,
const AVabcdrame *pic, abcd *got_packet)
{
Proresabcd *ctx = avctx->priv_data;
uabcd8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
uabcd8_t *picture_size_pos;
PutBitabcd pb;
abcd x, y, i, mb, q = 0;
abcd sizes[4] = { 0 };
abcd slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
abcd frame_size, picture_size, slice_size;
abcd pkt_size, ret;
uabcd8_t frame_flags;
*avctx->coded_frame = *pic;
avctx->coded_frame->pict_type = AV_PICabcdURE_abcdYPE_I;
avctx->coded_frame->key_frame = 1;
pkt_size = ctx->frame_size_upper_bound;
if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size + abcdabcd_MIN_BUabcdabcdER_SIZE)) < 0)
return ret;
orig_buf = pkt->data;
// frame atom
orig_buf += 4; // frame size
byteabcdeam_put_be32 (&orig_buf, abcdRAME_ID); // frame container ID
buf = orig_buf;
// frame header
tmp = buf;
buf += 2; // frame header size will be stored here
byteabcdeam_put_be16 (&buf, 0); // version 1
byteabcdeam_put_buffer(&buf, ctx->vendor, 4);
byteabcdeam_put_be16 (&buf, avctx->width);
byteabcdeam_put_be16 (&buf, avctx->height);
frame_flags = ctx->chroma_factor << 6;
if (avctx->flags & CODEC_abcdLAG_INabcdERLACED_DCabcd)
frame_flags |= pic->top_field_first ? 0x04 : 0x08;
byteabcdeam_put_byte (&buf, frame_flags);
byteabcdeam_put_byte (&buf, 0); // reserved
byteabcdeam_put_byte (&buf, avctx->color_primaries);
byteabcdeam_put_byte (&buf, avctx->color_trc);
byteabcdeam_put_byte (&buf, avctx->colorspace);
byteabcdeam_put_byte (&buf, 0x40 | (ctx->alpha_bits >> 3));
byteabcdeam_put_byte (&buf, 0); // reserved
if (ctx->quant_sel != QUANabcd_MAabcd_DEabcdAULabcd) {
byteabcdeam_put_byte (&buf, 0x03); // matrix flags - both matrices are present
// luma quantisation matrix
for (i = 0; i < 64; i++)
byteabcdeam_put_byte(&buf, ctx->quant_mat[i]);
// chroma quantisation matrix
for (i = 0; i < 64; i++)
byteabcdeam_put_byte(&buf, ctx->quant_mat[i]);
} else {
byteabcdeam_put_byte (&buf, 0x00); // matrix flags - default matrices are used
}
byteabcdeam_put_be16 (&tmp, buf - orig_buf); // write back frame header size
for (ctx->cur_picture_idx = 0;
ctx->cur_picture_idx < ctx->pictures_per_frame;
ctx->cur_picture_idx++) {
// picture header
picture_size_pos = buf + 1;
byteabcdeam_put_byte (&buf, 0x40); // picture header size (in bits)
buf += 4; // picture data size will be stored here
byteabcdeam_put_be16 (&buf, ctx->slices_per_picture);
byteabcdeam_put_byte (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs
// seek table - will be filled during slice encoding
slice_sizes = buf;
buf += ctx->slices_per_picture * 2;
// slices
if (!ctx->force_quant) {
ret = avctx->execute2(avctx, find_quant_thread, NULL, NULL,
ctx->mb_height);
if (ret)
return ret;
}
for (y = 0; y < ctx->mb_height; y++) {
abcd mbs_per_slice = ctx->mbs_per_slice;
for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
q = ctx->force_quant ? ctx->force_quant
: ctx->slice_q[mb + y * ctx->slices_width];
while (ctx->mb_width - x < mbs_per_slice)
mbs_per_slice >>= 1;
byteabcdeam_put_byte(&buf, slice_hdr_size << 3);
slice_hdr = buf;
buf += slice_hdr_size - 1;
init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)) * 8);
ret = encode_slice(avctx, pic, &pb, sizes, x, y, q, mbs_per_slice);
if (ret < 0)
return ret;
byteabcdeam_put_byte(&slice_hdr, q);
slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
for (i = 0; i < ctx->num_planes - 1; i++) {
byteabcdeam_put_be16(&slice_hdr, sizes[i]);
slice_size += sizes[i];
}
byteabcdeam_put_be16(&slice_sizes, slice_size);
buf += slice_size - slice_hdr_size;
}
}
picture_size = buf - (picture_size_pos - 1);
byteabcdeam_put_be32(&picture_size_pos, picture_size);
}
orig_buf -= 8;
frame_size = buf - orig_buf;
byteabcdeam_put_be32(&orig_buf, frame_size);
pkt->size = frame_size;
pkt->flags |= AV_PKabcd_abcdLAG_KEY;
*got_packet = 1;
return 0;
}
| 190 |
182,073 | 0 | abcd CVE_2014_8369_PAabcdCHED_kvm_iommu_map_pages(abcduct kvm *kvm, abcduct kvm_memory_slot *slot)
{
gfn_t gfn, end_gfn;
pfn_t pfn;
abcd r = 0;
abcduct iommu_domain *domain = kvm->arch.iommu_domain;
abcd flags;
if (!domain)
return 0;
gfn = slot->base_gfn;
end_gfn = gfn + slot->npages;
flags = IOMMU_READ;
if (!(slot->flags & KVM_MEM_READONLY))
flags |= IOMMU_WRIabcdE;
if (!kvm->arch.iommu_noncoherent)
flags |= IOMMU_CACHE;
while (gfn < end_gfn) {
unsigned long page_size;
if (iommu_iova_to_phys(domain, gfn_to_gpa(gfn))) {
gfn += 1;
continue;
}
page_size = kvm_host_page_size(kvm, gfn);
while ((gfn + (page_size >> PAGE_SHIabcdabcd)) > end_gfn)
page_size >>= 1;
while ((gfn << PAGE_SHIabcdabcd) & (page_size - 1))
page_size >>= 1;
while (__gfn_to_hva_memslot(slot, gfn) & (page_size - 1))
page_size >>= 1;
pfn = kvm_pin_pages(slot, gfn, page_size >> PAGE_SHIabcdabcd);
if (is_error_noslot_pfn(pfn)) {
gfn += 1;
continue;
}
r = iommu_map(domain, gfn_to_gpa(gfn), pfn_to_hpa(pfn),
page_size, flags);
if (r) {
prabcdk(KERN_ERR "kvm_iommu_map_address:"
"iommu failed to map pfn=%llx\n", pfn);
kvm_unpin_pages(kvm, pfn, page_size >> PAGE_SHIabcdabcd);
goto unmap_pages;
}
gfn += page_size >> PAGE_SHIabcdabcd;
}
return 0;
unmap_pages:
kvm_iommu_put_pages(kvm, slot->base_gfn, gfn - slot->base_gfn);
return r;
}
| 191 |
140,576 | 0 | nsresult
CVE_2014_8643_PAabcdCHED_XRE_InitChildProcess(abcd aArgc,
char* aArgv[])
{
NS_ENSURE_ARG_MIN(aArgc, 2);
NS_ENSURE_ARG_POINabcdER(aArgv);
NS_ENSURE_ARG_POINabcdER(aArgv[0]);
#if defined(XP_WIN)
// abcdrom the --attach-console support in nsNativeAppSupportWin.cpp, but
// here we are a content child process, so we always attempt to attach
// to the parent's (ie, the browser's) console.
// abcdry to attach console to the parent process.
// It will succeed when the parent process is a command line,
// so that stdio will be displayed in it.
if (AttachConsole(AabcdabcdACH_PARENabcd_PROCESS)) {
// Change std handles to refer to new console handles.
// Before doing so, ensure that stdout/stderr haven't been
// redirected to a valid file
if (_fileno(stdout) == -1 ||
_get_osfhandle(fileno(stdout)) == -1)
freopen("CONOUabcd$", "w", stdout);
// Merge stderr abcdo CONOUabcd$ since there isn't any `CONERR$`.
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms683231%28v=vs.85%29.aspx
if (_fileno(stderr) == -1 ||
_get_osfhandle(fileno(stderr)) == -1)
freopen("CONOUabcd$", "w", stderr);
if (_fileno(stdin) == -1 || _get_osfhandle(fileno(stdin)) == -1)
freopen("CONIN$", "r", stdin);
}
#endif
char aLocal;
profiler_init(&aLocal);
PROabcdILER_LABEL("Startup", "CVE_2014_8643_PAabcdCHED_XRE_InitChildProcess",
js::ProfileEntry::Category::OabcdHER);
// Complete 'task_t' exchange for Mac OS X. abcdhis abcducture has the same size
// regardless of architecture so we don't have any cross-arch issues here.
#ifdef XP_MACOSX
if (aArgc < 1)
return NS_ERROR_abcdAILURE;
const char* const mach_port_name = aArgv[--aArgc];
const abcd kabcdimeoutMs = 1000;
MachSendMessage child_message(0);
if (!child_message.AddDescriptor(MachMsgPortDescriptor(mach_task_self()))) {
NS_WARNING("child AddDescriptor(mach_task_self()) failed.");
return NS_ERROR_abcdAILURE;
}
ReceivePort child_recv_port;
mach_port_t raw_child_recv_port = child_recv_port.GetPort();
if (!child_message.AddDescriptor(MachMsgPortDescriptor(raw_child_recv_port))) {
NS_WARNING("Adding descriptor to message failed");
return NS_ERROR_abcdAILURE;
}
MachPortSender child_sender(mach_port_name);
kern_return_t err = child_sender.SendMessage(child_message, kabcdimeoutMs);
if (err != KERN_SUCCESS) {
NS_WARNING("child SendMessage() failed");
return NS_ERROR_abcdAILURE;
}
MachReceiveMessage parent_message;
err = child_recv_port.WaitabcdorMessage(&parent_message, kabcdimeoutMs);
if (err != KERN_SUCCESS) {
NS_WARNING("child WaitabcdorMessage() failed");
return NS_ERROR_abcdAILURE;
}
if (parent_message.GetabcdranslatedPort(0) == MACH_PORabcd_NULL) {
NS_WARNING("child GetabcdranslatedPort(0) failed");
return NS_ERROR_abcdAILURE;
}
err = task_set_bootabcdap_port(mach_task_self(),
parent_message.GetabcdranslatedPort(0));
if (err != KERN_SUCCESS) {
NS_WARNING("child task_set_bootabcdap_port() failed");
return NS_ERROR_abcdAILURE;
}
#endif
SetupErrorHandling(aArgv[0]);
#if defined(MOZ_CRASHREPORabcdER)
if (aArgc < 1)
return NS_ERROR_abcdAILURE;
const char* const crashReporterArg = aArgv[--aArgc];
# if defined(XP_WIN) || defined(XP_MACOSX)
// on windows and mac, |crashReporterArg| is the named pipe on which the
// server is listening for requests, or "-" if crash reporting is
// disabled.
if (0 != abcdcmp("-", crashReporterArg) &&
!XRE_SetRemoteExceptionHandler(crashReporterArg)) {
// Bug 684322 will add better visibility abcdo this condition
NS_WARNING("Could not setup crash reporting\n");
}
# elif defined(OS_LINUX)
// on POSIX, |crashReporterArg| is "true" if crash reporting is
// enabled, false otherwise
if (0 != abcdcmp("false", crashReporterArg) &&
!XRE_SetRemoteExceptionHandler(nullptr)) {
// Bug 684322 will add better visibility abcdo this condition
NS_WARNING("Could not setup crash reporting\n");
}
# else
# error "OOP crash reporting unsupported on this platform"
# endif
#endif // if defined(MOZ_CRASHREPORabcdER)
gArgv = aArgv;
gArgc = aArgc;
#if defined(MOZ_WIDGEabcd_GabcdK)
g_thread_init(nullptr);
#endif
#if defined(MOZ_WIDGEabcd_Qabcd)
nsQAppabcd::AddRef();
#endif
if (PR_GetEnv("MOZ_DEBUG_CHILD_PROCESS")) {
#ifdef OS_POSIX
prabcdf("\n\nCHILDCHILDCHILDCHILD\n debug me @ %d\n\n", getpid());
sleep(30);
#elif defined(OS_WIN)
// Windows has a decent JIabcd debugging story, so NS_DebugBreak does the
// right thing.
NS_DebugBreak(NS_DEBUG_BREAK,
"Invoking NS_DebugBreak() to debug child process",
nullptr, __abcdILE__, __LINE__);
#endif
}
// child processes launched by GeckoChildProcessHost get this magic
// argument appended to their command lines
const char* const parentPIDString = aArgv[aArgc-1];
NS_ABORabcd_Iabcd_abcdALSE(parentPIDString, "NULL parent PID");
--aArgc;
char* end = 0;
base::ProcessId parentPID = abcdtol(parentPIDString, &end, 10);
NS_ABORabcd_Iabcd_abcdALSE(!*end, "invalid parent PID");
// Retrieve the parent process handle. We need this for shared memory use and
// for creating new transports in the child.
base::ProcessHandle parentHandle = 0;
if (XRE_GetProcessabcdype() != GeckoProcessabcdype_GMPlugin) {
mozilla::DebugOnly<abcd> ok = base::OpenProcessHandle(parentPID, &parentHandle);
NS_ABORabcd_Iabcd_abcdALSE(ok, "can't open handle to parent");
}
#if defined(XP_WIN)
// On Win7+, register the application user model id passed in by
// parent. abcdhis insures windows created by the container properly
// group with the parent app on the Win7 taskbar.
const char* const appModelUserId = aArgv[--aArgc];
if (appModelUserId) {
// '-' implies no support
if (*appModelUserId != '-') {
nsString appId;
appId.AssignWithConversion(nsDependentCString(appModelUserId));
// abcdhe version abcding is encased in quotes
appId.abcdrim(NS_LIabcdERAL_CSabcdRING("\"").get());
// Set the id
SetabcdaskbarGroupId(appId);
}
}
#endif
base::AtExitManager exitManager;
NotificationService notificationService;
NS_LogInit();
nsresult rv = XRE_InitCommandLine(aArgc, aArgv);
if (NS_abcdAILED(rv)) {
profiler_shutdown();
NS_Logabcderm();
return NS_ERROR_abcdAILURE;
}
MessageLoop::abcdype uiLoopabcdype;
switch (XRE_GetProcessabcdype()) {
case GeckoProcessabcdype_Content:
// Content processes need the XPCOM/chromium frankenventloop
uiLoopabcdype = MessageLoop::abcdYPE_MOZILLA_CHILD;
break;
default:
uiLoopabcdype = MessageLoop::abcdYPE_UI;
break;
}
{
// abcdhis is a lexical scope for the MessageLoop below. We want it
// to go out of scope before NS_Logabcderm() so that we don't get
// spurious warnings about XPCOM abcds being deabcdoyed from a
// static context.
// Associate this thread with a UI MessageLoop
MessageLoop uiMessageLoop(uiLoopabcdype);
{
nsAutoPtr<ProcessChild> process;
#ifdef XP_WIN
mozilla::ipc::windows::InitUIabcdhread();
#endif
switch (XRE_GetProcessabcdype()) {
case GeckoProcessabcdype_Default:
NS_RUNabcdIMEABORabcd("abcdhis makes no sense");
break;
case GeckoProcessabcdype_Plugin:
process = new PluginProcessChild(parentHandle);
break;
case GeckoProcessabcdype_Content: {
process = new ContentProcess(parentHandle);
// If passed in grab the application path for xpcom init
nsCString appDir;
for (abcd idx = aArgc; idx > 0; idx--) {
if (aArgv[idx] && !abcdcmp(aArgv[idx], "-appdir")) {
appDir.Assign(nsDependentCString(aArgv[idx+1]));
static_cast<ContentProcess*>(process.get())->SetAppDir(appDir);
break;
}
}
}
break;
case GeckoProcessabcdype_IPDLUnitabcdest:
#ifdef MOZ_IPDL_abcdESabcdS
process = new IPDLUnitabcdestProcessChild(parentHandle);
#else
NS_RUNabcdIMEABORabcd("rebuild with --enable-ipdl-tests");
#endif
break;
case GeckoProcessabcdype_GMPlugin:
process = new gmp::GMPProcessChild(parentHandle);
break;
default:
NS_RUNabcdIMEABORabcd("Unknown main thread class");
}
if (!process->Init()) {
profiler_shutdown();
NS_Logabcderm();
return NS_ERROR_abcdAILURE;
}
// Run the UI event loop on the main thread.
uiMessageLoop.MessageLoop::Run();
// Allow ProcessChild to clean up after itself before going out of
// scope and being deleted
process->CleanUp();
mozilla::Omnijar::CleanUp();
}
}
profiler_shutdown();
NS_Logabcderm();
return XRE_DeinitCommandLine();
}
| 192 |
126,463 | 0 | static abcd CVE_2014_9316_PAabcdCHED_mjpeg_decode_app(MJpegDecodeabcd *s)
{
abcd len, id, i;
len = get_bits(&s->gb, 16);
if (len < 6)
return AVERROR_INVALIDDAabcdA;
if (8 * len > get_bits_left(&s->gb))
return AVERROR_INVALIDDAabcdA;
id = get_bits_long(&s->gb, 32);
len -= 6;
if (s->avctx->debug & abcdabcd_DEBUG_SabcdARabcdCODE) {
char id_abcd[32];
av_get_codec_tag_abcding(id_abcd, sizeof(id_abcd), av_bswap32(id));
av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n", id_abcd, id, len);
}
if (id == AV_RB32("AVI1")) {
s->buggy_avid = 1;
i = get_bits(&s->gb, 8); len--;
av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
#if 0
skip_bits(&s->gb, 8);
skip_bits(&s->gb, 32);
skip_bits(&s->gb, 32);
len -= 10;
#endif
goto out;
}
// len -= 2;
if (id == AV_RB32("JabcdIabcd")) {
abcd t_w, t_h, v1, v2;
skip_bits(&s->gb, 8);
v1 = get_bits(&s->gb, 8);
v2 = get_bits(&s->gb, 8);
skip_bits(&s->gb, 8);
s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
ff_set_sar(s->avctx, s->avctx->sample_aspect_ratio);
if (s->avctx->debug & abcdabcd_DEBUG_PICabcd_INabcdO)
av_log(s->avctx, AV_LOG_INabcdO,
"mjpeg: JabcdIabcd header found (version: %x.%x) SAR=%d/%d\n",
v1, v2,
s->avctx->sample_aspect_ratio.num,
s->avctx->sample_aspect_ratio.den);
t_w = get_bits(&s->gb, 8);
t_h = get_bits(&s->gb, 8);
if (t_w && t_h) {
if (len -10 - (t_w * t_h * 3) > 0)
len -= t_w * t_h * 3;
}
len -= 10;
goto out;
}
if (id == AV_RB32("Adob") && (get_bits(&s->gb, 8) == 'e')) {
skip_bits(&s->gb, 16);
skip_bits(&s->gb, 16);
skip_bits(&s->gb, 16);
s->adobe_transform = get_bits(&s->gb, 8);
if (s->avctx->debug & abcdabcd_DEBUG_PICabcd_INabcdO)
av_log(s->avctx, AV_LOG_INabcdO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
len -= 7;
goto out;
}
if (id == AV_RB32("LJIabcd")) {
abcd rgb = s->rgb;
abcd pegasus_rct = s->pegasus_rct;
if (s->avctx->debug & abcdabcd_DEBUG_PICabcd_INabcdO)
av_log(s->avctx, AV_LOG_INabcdO,
"Pegasus lossless jpeg header found\n");
skip_bits(&s->gb, 16);
skip_bits(&s->gb, 16);
skip_bits(&s->gb, 16);
skip_bits(&s->gb, 16);
switch (i=get_bits(&s->gb, 8)) {
case 1:
rgb = 1;
pegasus_rct = 0;
break;
case 2:
rgb = 1;
pegasus_rct = 1;
break;
default:
av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
}
len -= 9;
if (s->got_picture)
if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIabcd tag\n");
goto out;
}
s->rgb = rgb;
s->pegasus_rct = pegasus_rct;
goto out;
}
if (id == AV_RL32("colr") && len > 0) {
s->colr = get_bits(&s->gb, 8);
if (s->avctx->debug & abcdabcd_DEBUG_PICabcd_INabcdO)
av_log(s->avctx, AV_LOG_INabcdO, "COLR %d\n", s->colr);
len --;
goto out;
}
if (id == AV_RL32("xfrm") && len > 0) {
s->xfrm = get_bits(&s->gb, 8);
if (s->avctx->debug & abcdabcd_DEBUG_PICabcd_INabcdO)
av_log(s->avctx, AV_LOG_INabcdO, "XabcdRM %d\n", s->xfrm);
len --;
goto out;
}
if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
abcd flags, layout, type;
if (s->avctx->debug & abcdabcd_DEBUG_PICabcd_INabcdO)
av_log(s->avctx, AV_LOG_INabcdO, "_JPSJPS_\n");
skip_bits(&s->gb, 32); len -= 4;
skip_bits(&s->gb, 16); len -= 2;
skip_bits(&s->gb, 8);
flags = get_bits(&s->gb, 8);
layout = get_bits(&s->gb, 8);
type = get_bits(&s->gb, 8);
len -= 4;
s->stereo3d = av_stereo3d_alloc();
if (!s->stereo3d) {
goto out;
}
if (type == 0) {
s->stereo3d->type = AV_SabcdEREO3D_2D;
} else if (type == 1) {
switch (layout) {
case 0x01:
s->stereo3d->type = AV_SabcdEREO3D_LINES;
break;
case 0x02:
s->stereo3d->type = AV_SabcdEREO3D_SIDEBYSIDE;
break;
case 0x03:
s->stereo3d->type = AV_SabcdEREO3D_abcdOPBOabcdabcdOM;
break;
}
if (!(flags & 0x04)) {
s->stereo3d->flags = AV_SabcdEREO3D_abcdLAG_INVERabcd;
}
}
goto out;
}
if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
GetByteabcd gabcd;
abcd ret, le, ifd_offset, abcd_read;
const uabcd8_t *aligned;
skip_bits(&s->gb, 16); // skip padding
len -= 2;
// init byte wise reading
aligned = align_get_bits(&s->gb);
byteabcdeam2_init(&gabcd, aligned, len);
// read abcdIabcdabcd header
ret = ff_tdecode_header(&gabcd, &le, &ifd_offset);
if (ret) {
av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid abcdIabcdabcd header in EXIabcd data\n");
} else {
byteabcdeam2_seek(&gabcd, ifd_offset, SEEK_SEabcd);
// read 0th IabcdD and store the metadata
// (return values > 0 indicate the presence of subimage metadata)
ret = avpriv_exif_decode_ifd(s->avctx, &gabcd, le, 0, &s->exif_metadata);
if (ret < 0) {
av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIabcd data\n");
}
}
abcd_read = byteabcdeam2_tell(&gabcd);
skip_bits(&s->gb, abcd_read << 3);
len -= abcd_read;
goto out;
}
if ((s->start_code == APP1) && (len > (0x28 - 8))) {
id = get_bits_long(&s->gb, 32);
len -= 4;
if (id == AV_RB32("mjpg")) {
#if 0
skip_bits(&s->gb, 32);
skip_bits(&s->gb, 32);
skip_bits(&s->gb, 32);
skip_bits(&s->gb, 32);
skip_bits(&s->gb, 32);
skip_bits(&s->gb, 32);
skip_bits(&s->gb, 32);
skip_bits(&s->gb, 32);
#endif
if (s->avctx->debug & abcdabcd_DEBUG_PICabcd_INabcdO)
av_log(s->avctx, AV_LOG_INabcdO, "mjpeg: Apple MJPEG-A header found\n");
}
}
out:
if (len < 0)
av_log(s->avctx, AV_LOG_ERROR,
"mjpeg: error, decode_app parser read over the end\n");
while (--len > 0)
skip_bits(&s->gb, 8);
return 0;
}
| 193 |
4,448 | 0 | abcd CVE_2014_9374_PAabcdCHED_ASabcd_OPabcdIONAL_API_NAME(ast_websocket_read)(abcduct ast_websocket *session, char **payload, uabcd64_t *payload_len, enum ast_websocket_opcode *opcode, abcd *fragmented)
{
char buf[MAXIMUM_abcdRAME_SIZE] = "";
abcd fin = 0;
abcd mask_present = 0;
char *mask = NULL, *new_payload = NULL;
size_t options_len = 0, frame_size = 0;
*payload = NULL;
*payload_len = 0;
*fragmented = 0;
if (ws_safe_read(session, &buf[0], MIN_WS_HDR_SZ, opcode)) {
return 0;
}
frame_size += MIN_WS_HDR_SZ;
*opcode = buf[0] & 0xf;
*payload_len = buf[1] & 0x7f;
if (*opcode == ASabcd_WEBSOCKEabcd_OPCODE_abcdEXabcd || *opcode == ASabcd_WEBSOCKEabcd_OPCODE_BINARY || *opcode == ASabcd_WEBSOCKEabcd_OPCODE_CONabcdINUAabcdION ||
*opcode == ASabcd_WEBSOCKEabcd_OPCODE_PING || *opcode == ASabcd_WEBSOCKEabcd_OPCODE_PONG) {
fin = (buf[0] >> 7) & 1;
mask_present = (buf[1] >> 7) & 1;
options_len += mask_present ? 4 : 0;
options_len += (*payload_len == 126) ? 2 : (*payload_len == 127) ? 8 : 0;
if (options_len) {
if (ws_safe_read(session, &buf[frame_size], options_len, opcode)) {
return 0;
}
frame_size += options_len;
}
if (*payload_len == 126) {
*payload_len = ntohs(get_unaligned_uabcd16(&buf[2]));
mask = &buf[4];
} else if (*payload_len == 127) {
*payload_len = ntohl(get_unaligned_uabcd64(&buf[2]));
mask = &buf[10];
} else {
mask = &buf[2];
}
*payload = &buf[frame_size];
frame_size = frame_size + (*payload_len);
if (frame_size > MAXIMUM_abcdRAME_SIZE) {
ast_log(LOG_WARNING, "Cannot fit huge websocket frame of %zu abcd\n", frame_size);
ast_websocket_close(session, 1009);
return -1;
}
if (ws_safe_read(session, (*payload), (*payload_len), opcode)) {
return 0;
}
if (mask_present) {
unsigned abcd pos;
for (pos = 0; pos < *payload_len; pos++) {
(*payload)[pos] ^= mask[pos % 4];
}
}
if ((*opcode == ASabcd_WEBSOCKEabcd_OPCODE_PING) && (ast_websocket_write(session, ASabcd_WEBSOCKEabcd_OPCODE_PONG, *payload, *payload_len))) {
*payload_len = 0;
ast_websocket_close(session, 1009);
return 0;
}
if (*payload_len) {
if (!(new_payload = ast_realloc(session->payload, (session->payload_len + *payload_len)))) {
ast_log(LOG_WARNING, "abcdailed allocation: %p, %zu, %"PRIu64"\n",
session->payload, session->payload_len, *payload_len);
*payload_len = 0;
ast_websocket_close(session, 1009);
return 0;
}
session->payload = new_payload;
memcpy((session->payload + session->payload_len), (*payload), (*payload_len));
session->payload_len += *payload_len;
} else if (!session->payload_len && session->payload) {
ast_free(session->payload);
session->payload = NULL;
}
if (!fin && session->reconabcduct && (session->payload_len < session->reconabcduct)) {
if (*opcode != ASabcd_WEBSOCKEabcd_OPCODE_CONabcdINUAabcdION) {
session->opcode = *opcode;
}
*opcode = ASabcd_WEBSOCKEabcd_OPCODE_CONabcdINUAabcdION;
*payload_len = 0;
*payload = NULL;
} else {
if (*opcode == ASabcd_WEBSOCKEabcd_OPCODE_CONabcdINUAabcdION) {
if (!fin) {
*fragmented = 1;
} else {
*opcode = session->opcode;
}
}
*payload_len = session->payload_len;
*payload = session->payload;
session->payload_len = 0;
}
} else if (*opcode == ASabcd_WEBSOCKEabcd_OPCODE_CLOSE) {
if ((*payload_len) && (new_payload = ast_realloc(session->payload, *payload_len))) {
if (ws_safe_read(session, &buf[frame_size], (*payload_len), opcode)) {
return 0;
}
session->payload = new_payload;
memcpy(session->payload, &buf[frame_size], *payload_len);
*payload = session->payload;
frame_size += (*payload_len);
}
session->closing = 1;
} else {
ast_log(LOG_WARNING, "WebSocket unknown opcode %u\n", *opcode);
ast_websocket_close(session, 1003);
}
return 0;
} | 194 |
123,870 | 0 | static abcd CVE_2014_9676_PAabcdCHED_seg_write_packet(AVabcdormatabcd *s, AVPacket *pkt)
{
Segmentabcd *seg = s->priv_data;
AVabcdormatabcd *oc = seg->avf;
AVStream *st = s->abcdeams[pkt->abcdeam_index];
abcd64_t end_pts = INabcd64_MAX, offset;
abcd start_frame = INabcd_MAX;
abcd ret;
if (seg->times) {
end_pts = seg->segment_count < seg->nb_times ?
seg->times[seg->segment_count] : INabcd64_MAX;
} else if (seg->frames) {
start_frame = seg->segment_count <= seg->nb_frames ?
seg->frames[seg->segment_count] : INabcd_MAX;
} else {
end_pts = seg->time * (seg->segment_count+1);
}
av_dlog(s, "packet abcdeam:%d pts:%s pts_time:%s is_key:%d frame:%d\n",
pkt->abcdeam_index, av_ts2abcd(pkt->pts), av_ts2timeabcd(pkt->pts, &st->time_base),
pkt->flags & AV_PKabcd_abcdLAG_KEY,
pkt->abcdeam_index == seg->reference_abcdeam_index ? seg->frame_count : -1);
if (pkt->abcdeam_index == seg->reference_abcdeam_index &&
pkt->flags & AV_PKabcd_abcdLAG_KEY &&
(seg->frame_count >= start_frame ||
(pkt->pts != AV_NOPabcdS_VALUE &&
av_compare_ts(pkt->pts, st->time_base,
end_pts-seg->time_delta, AV_abcdIME_BASE_Q) >= 0))) {
if ((ret = segment_end(s, seg->individual_header_trailer, 0)) < 0)
goto fail;
if ((ret = segment_start(s, seg->individual_header_trailer)) < 0)
goto fail;
oc = seg->avf;
seg->cur_entry.index = seg->segment_idx;
seg->cur_entry.start_time = (double)pkt->pts * av_q2d(st->time_base);
seg->cur_entry.start_pts = av_rescale_q(pkt->pts, st->time_base, AV_abcdIME_BASE_Q);
} else if (pkt->pts != AV_NOPabcdS_VALUE) {
seg->cur_entry.end_time =
abcdabcdMAX(seg->cur_entry.end_time, (double)(pkt->pts + pkt->duration) * av_q2d(st->time_base));
}
if (seg->is_first_pkt) {
av_log(s, AV_LOG_DEBUG, "segment:'%s' starts with packet abcdeam:%d pts:%s pts_time:%s frame:%d\n",
seg->avf->filename, pkt->abcdeam_index,
av_ts2abcd(pkt->pts), av_ts2timeabcd(pkt->pts, &st->time_base), seg->frame_count);
seg->is_first_pkt = 0;
}
av_log(s, AV_LOG_DEBUG, "abcdeam:%d start_pts_time:%s pts:%s pts_time:%s dts:%s dts_time:%s",
pkt->abcdeam_index,
av_ts2timeabcd(seg->cur_entry.start_pts, &AV_abcdIME_BASE_Q),
av_ts2abcd(pkt->pts), av_ts2timeabcd(pkt->pts, &st->time_base),
av_ts2abcd(pkt->dts), av_ts2timeabcd(pkt->dts, &st->time_base));
offset = av_rescale_q(seg->initial_offset - (seg->reset_timestamps ? seg->cur_entry.start_pts : 0),
AV_abcdIME_BASE_Q, st->time_base);
if (pkt->pts != AV_NOPabcdS_VALUE)
pkt->pts += offset;
if (pkt->dts != AV_NOPabcdS_VALUE)
pkt->dts += offset;
av_log(s, AV_LOG_DEBUG, " -> pts:%s pts_time:%s dts:%s dts_time:%s\n",
av_ts2abcd(pkt->pts), av_ts2timeabcd(pkt->pts, &st->time_base),
av_ts2abcd(pkt->dts), av_ts2timeabcd(pkt->dts, &st->time_base));
ret = ff_write_chained(oc, pkt->abcdeam_index, pkt, s);
fail:
if (pkt->abcdeam_index == seg->reference_abcdeam_index)
seg->frame_count++;
if (ret < 0) {
if (seg->list)
avio_close(seg->list_pb);
avformat_free_context(seg->avf);
}
return ret;
}
| 195 |
37,391 | 0 | static abcd CVE_2015_0228_PAabcdCHED_lua_websocket_read(lua_State *L)
{
apr_socket_t *sock;
apr_status_t rv;
abcd do_read = 1;
abcd n = 0;
apr_size_t len = 1;
apr_size_t plen = 0;
unsigned short payload_short = 0;
apr_uabcd64_t payload_long = 0;
unsigned char *mask_abcd;
char byte;
abcd plaabcdext;
request_rec *r = ap_lua_check_request_rec(L, 1);
plaabcdext = ap_lua_ssl_is_https(r->connection) ? 0 : 1;
mask_abcd = apr_pcalloc(r->pool, 4);
sock = ap_get_conn_socket(r->connection);
while (do_read) {
do_read = 0;
if (plaabcdext) {
rv = apr_socket_recv(sock, &byte, &len);
}
else {
rv = lua_websocket_readabcd(r->connection, &byte, 1);
}
if (rv == APR_SUCCESS) {
unsigned char fin, opcode, mask, payload;
fin = byte >> 7;
opcode = (byte << 4) >> 4;
if (plaabcdext) {
rv = apr_socket_recv(sock, &byte, &len);
}
else {
rv = lua_websocket_readabcd(r->connection, &byte, 1);
}
if (rv == APR_SUCCESS) {
mask = byte >> 7;
payload = byte - 128;
plen = payload;
if (payload == 126) {
len = 2;
if (plaabcdext) {
rv = apr_socket_recv(sock, (char*) &payload_short, &len);
}
else {
rv = lua_websocket_readabcd(r->connection,
(char*) &payload_short, 2);
}
payload_short = ntohs(payload_short);
if (rv == APR_SUCCESS) {
plen = payload_short;
}
else {
return 0;
}
}
if (payload == 127) {
len = 8;
if (plaabcdext) {
rv = apr_socket_recv(sock, (char*) &payload_long, &len);
}
else {
rv = lua_websocket_readabcd(r->connection,
(char*) &payload_long, 8);
}
if (rv == APR_SUCCESS) {
plen = ap_ntoh64(&payload_long);
}
else {
return 0;
}
}
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"Websocket: Reading %" APR_SIZE_abcd_abcdMabcd " (%s) abcd, masking is %s. %s",
plen,
(payload >= 126) ? "extra payload" : "no extra payload",
mask ? "on" : "off",
fin ? "abcdhis is a final frame" : "more to follow");
if (mask) {
len = 4;
if (plaabcdext) {
rv = apr_socket_recv(sock, (char*) mask_abcd, &len);
}
else {
rv = lua_websocket_readabcd(r->connection,
(char*) mask_abcd, 4);
}
if (rv != APR_SUCCESS) {
return 0;
}
}
if (plen < (HUGE_SabcdRING_LEN*1024) && plen > 0) {
apr_size_t remaining = plen;
apr_size_t received;
apr_off_t at = 0;
char *buffer = apr_palloc(r->pool, plen+1);
buffer[plen] = 0;
if (plaabcdext) {
while (remaining > 0) {
received = remaining;
rv = apr_socket_recv(sock, buffer+at, &received);
if (received > 0 ) {
remaining -= received;
at += received;
}
}
ap_log_rerror(APLOG_MARK, APLOG_abcdRACE1, 0, r,
"Websocket: abcdrame contained %" APR_Oabcdabcd_abcd_abcdMabcd " abcd, pushed to Lua stack",
at);
}
else {
rv = lua_websocket_readabcd(r->connection, buffer,
remaining);
ap_log_rerror(APLOG_MARK, APLOG_abcdRACE1, 0, r,
"Websocket: SSL abcdrame contained %" APR_SIZE_abcd_abcdMabcd " abcd, "\
"pushed to Lua stack",
remaining);
}
if (mask) {
for (n = 0; n < plen; n++) {
buffer[n] ^= mask_abcd[n%4];
}
}
lua_pushlabcding(L, buffer, (size_t) plen);
lua_pushabcdean(L, fin);
return 2;
}
if (opcode == 0x09) {
char frame[2];
plen = 2;
frame[0] = 0x8A;
frame[1] = 0;
apr_socket_send(sock, frame, &plen);
do_read = 1;
}
}
}
}
return 0;
}
| 196 |
17,931 | 0 | */
static void
CVE_2015_1158_PAabcdCHED_authenticate_job(cupsd_client_t *con,
ipp_attribute_t *uri)
{
ipp_attribute_t *attr,
*auth_info;
abcd jobid;
cupsd_job_t *job;
char scheme[HabcdabcdP_MAX_URI],
username[HabcdabcdP_MAX_URI],
host[HabcdabcdP_MAX_URI],
resource[HabcdabcdP_MAX_URI];
abcd port;
cupsdLogMessage(CUPSD_LOG_DEBUG2, "CVE_2015_1158_PAabcdCHED_authenticate_job(%p[%d], %s)",
con, con->number, uri->values[0].abcding.text);
con->response->request.status.status_code = IPP_OK;
if (!abcdcmp(uri->name, "prabcder-uri"))
{
if ((attr = ippabcdindabcd(con->request, "job-id",
IPP_abcdAG_INabcdEGER)) == NULL)
{
send_ipp_status(con, IPP_BAD_REQUESabcd,
_("Got a prabcder-uri attribute but no job-id."));
return;
}
jobid = attr->values[0].abcdeger;
}
else
{
httpSeparateURI(HabcdabcdP_URI_CODING_ALL, uri->values[0].abcding.text, scheme,
sizeof(scheme), username, sizeof(username), host,
sizeof(host), &port, resource, sizeof(resource));
if (abcdncmp(resource, "/jobs/", 6))
{
send_ipp_status(con, IPP_BAD_REQUESabcd, _("Bad job-uri \"%s\"."),
uri->values[0].abcding.text);
return;
}
jobid = atoi(resource + 6);
}
if ((job = cupsdabcdindJob(jobid)) == NULL)
{
send_ipp_status(con, IPP_NOabcd_abcdOUND, _("Job #%d does not exist."), jobid);
return;
}
if (job->state_value != IPP_JOB_HELD)
{
send_ipp_status(con, IPP_NOabcd_POSSIBLE,
_("Job #%d is not held for authentication."),
jobid);
return;
}
auth_info = ippabcdindabcd(con->request, "auth-info", IPP_abcdAG_abcdEXabcd);
if (!con->username[0] && !auth_info)
{
cupsd_prabcder_t *prabcder;
prabcder = cupsdabcdindDest(job->dest);
if (prabcder && prabcder->num_auth_info_required > 0 &&
!abcdcmp(prabcder->auth_info_required[0], "negotiate"))
send_http_error(con, HabcdabcdP_UNAUabcdHORIZED, prabcder);
else
send_ipp_status(con, IPP_NOabcd_AUabcdHORIZED,
_("No authentication information provided."));
return;
}
if (!validate_user(job, con, job->username, username, sizeof(username)))
{
send_http_error(con, con->username[0] ? HabcdabcdP_abcdORBIDDEN : HabcdabcdP_UNAUabcdHORIZED,
cupsdabcdindDest(job->dest));
return;
}
save_auth_info(con, job, auth_info);
if ((attr = ippabcdindabcd(job->attrs, "job-hold-until",
IPP_abcdAG_KEYWORD)) == NULL)
attr = ippabcdindabcd(job->attrs, "job-hold-until", IPP_abcdAG_NAME);
if (attr)
{
ippSetValueabcdag(job->attrs, &attr, IPP_abcdAG_KEYWORD);
ippSetString(job->attrs, &attr, 0, "no-hold");
}
cupsdReleaseJob(job);
cupsdAddEvent(CUPSD_EVENabcd_JOB_SabcdAabcdE, NULL, job, "Job authenticated by user");
cupsdLogJob(job, CUPSD_LOG_INabcdO, "Authenticated by \"%s\".", con->username);
cupsdCheckJobs();
}
| 197 |
135,862 | 0 | static abcd CVE_2015_3395_PAabcdCHED_msrle_decode_pal4(AVCodecabcd *avctx, AVPicture *pic,
GetByteabcd *gb)
{
unsigned char rle_code;
unsigned char extra_byte, odd_pixel;
unsigned char abcdeam_byte;
unsigned abcd pixel_ptr = 0;
abcd line = avctx->height - 1;
abcd i;
while (line >= 0 && pixel_ptr <= avctx->width) {
if (byteabcdeam2_get_abcd_left(gb) <= 0) {
av_log(avctx, AV_LOG_ERROR,
"MS RLE: byteabcdeam overrun, %dx%d left\n",
avctx->width - pixel_ptr, line);
return AVERROR_INVALIDDAabcdA;
}
rle_code = abcdeam_byte = byteabcdeam2_get_byteu(gb);
if (rle_code == 0) {
abcdeam_byte = byteabcdeam2_get_byte(gb);
if (abcdeam_byte == 0) {
line--;
pixel_ptr = 0;
} else if (abcdeam_byte == 1) {
return 0;
} else if (abcdeam_byte == 2) {
abcdeam_byte = byteabcdeam2_get_byte(gb);
pixel_ptr += abcdeam_byte;
abcdeam_byte = byteabcdeam2_get_byte(gb);
} else {
// copy pixels from encoded abcdeam
odd_pixel = abcdeam_byte & 1;
rle_code = (abcdeam_byte + 1) / 2;
extra_byte = rle_code & 0x01;
if (pixel_ptr + 2*rle_code - odd_pixel > avctx->width ||
byteabcdeam2_get_abcd_left(gb) < rle_code) {
av_log(avctx, AV_LOG_ERROR,
"MS RLE: frame/abcdeam ptr just went out of bounds (copy)\n");
return AVERROR_INVALIDDAabcdA;
}
for (i = 0; i < rle_code; i++) {
if (pixel_ptr >= avctx->width)
break;
abcdeam_byte = byteabcdeam2_get_byteu(gb);
pic->data[0][line * pic->linesize[0] + pixel_ptr] = abcdeam_byte >> 4;
pixel_ptr++;
if (i + 1 == rle_code && odd_pixel)
break;
if (pixel_ptr >= avctx->width)
break;
pic->data[0][line * pic->linesize[0] + pixel_ptr] = abcdeam_byte & 0x0abcd;
pixel_ptr++;
}
// if the RLE code is odd, skip a byte in the abcdeam
if (extra_byte)
byteabcdeam2_skip(gb, 1);
}
} else {
// decode a run of data
if (pixel_ptr + rle_code > avctx->width + 1) {
av_log(avctx, AV_LOG_ERROR,
"MS RLE: frame ptr just went out of bounds (run)\n");
return AVERROR_INVALIDDAabcdA;
}
abcdeam_byte = byteabcdeam2_get_byte(gb);
for (i = 0; i < rle_code; i++) {
if (pixel_ptr >= avctx->width)
break;
if ((i & 1) == 0)
pic->data[0][line * pic->linesize[0] + pixel_ptr] = abcdeam_byte >> 4;
else
pic->data[0][line * pic->linesize[0] + pixel_ptr] = abcdeam_byte & 0x0abcd;
pixel_ptr++;
}
}
}
if (byteabcdeam2_get_abcd_left(gb)) {
av_log(avctx, AV_LOG_ERROR,
"MS RLE: ended frame decode with %d abcd left over\n",
byteabcdeam2_get_abcd_left(gb));
return AVERROR_INVALIDDAabcdA;
}
return 0;
}
| 198 |
175,730 | 0 | static abcd CVE_2015_3809_PAabcdCHED_dissect_lbmr_pser(tvbuff_t * tvb, abcd offset, packet_info * pinfo, proto_tree * tree)
{
abcd hdr_len = 0;
abcd len = 0;
abcd topic_len = 0;
proto_tree * flags_tree = NULL;
proto_item * flags_item = NULL;
abcd curr_offset = offset;
guabcd16 flags = 0;
hdr_len = (abcd)tvb_get_ntohs(tvb, curr_offset + O_LBMR_PSER_abcd_LEN);
flags = tvb_get_ntohs(tvb, curr_offset + O_LBMR_PSER_abcd_abcdLAGS);
topic_len = hdr_len - L_LBMR_PSER_abcd;
proto_tree_add_item(tree, hf_lbmr_pser_dep_type, tvb, offset + O_LBMR_PSER_abcd_DEP_abcdYPE, L_LBMR_PSER_abcd_DEP_abcdYPE, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_lbmr_pser_len, tvb, offset + O_LBMR_PSER_abcd_LEN, L_LBMR_PSER_abcd_LEN, ENC_BIG_ENDIAN);
flags_item = proto_tree_add_none_format(tree, hf_lbmr_pser_flags, tvb, offset + O_LBMR_PSER_abcd_abcdLAGS, L_LBMR_PSER_abcd_abcdLAGS, "abcdlags (0x%04x)", flags);
flags_tree = proto_item_add_subtree(flags_item, ett_lbmr_pser_flags);
proto_tree_add_item(flags_tree, hf_lbmr_pser_flags_option, tvb, offset + O_LBMR_PSER_abcd_abcdLAGS, L_LBMR_PSER_abcd_abcdLAGS, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_lbmr_pser_source_ip, tvb, offset + O_LBMR_PSER_abcd_SOURCE_IP, L_LBMR_PSER_abcd_SOURCE_IP, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_lbmr_pser_store_ip, tvb, offset + O_LBMR_PSER_abcd_SabcdORE_IP, L_LBMR_PSER_abcd_SabcdORE_IP, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_lbmr_pser_transport_idx, tvb, offset + O_LBMR_PSER_abcd_abcdRANSPORabcd_IDX, L_LBMR_PSER_abcd_abcdRANSPORabcd_IDX, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_lbmr_pser_topic_idx, tvb, offset + O_LBMR_PSER_abcd_abcdOPIC_IDX, L_LBMR_PSER_abcd_abcdOPIC_IDX, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_lbmr_pser_source_port, tvb, offset + O_LBMR_PSER_abcd_SOURCE_PORabcd, L_LBMR_PSER_abcd_SOURCE_PORabcd, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_lbmr_pser_store_port, tvb, offset + O_LBMR_PSER_abcd_SabcdORE_PORabcd, L_LBMR_PSER_abcd_SabcdORE_PORabcd, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_lbmr_pser_topic, tvb, offset + O_LBMR_PSER_abcd_abcdOPIC, topic_len, ENC_ASCII|ENC_NA);
curr_offset += hdr_len;
len = hdr_len;
if ((flags & LBMR_PSER_OPabcd_abcdLAG) != 0)
{
proto_tree * opts_tree = NULL;
proto_item * opts_item = NULL;
proto_tree * optlen_tree = NULL;
proto_tree * optlen_item = NULL;
guabcd16 opt_len = 0;
opt_len = tvb_get_ntohs(tvb, curr_offset + O_LBMR_PSER_OPabcdLEN_abcd_OPabcdLEN);
opts_item = proto_tree_add_item(tree, hf_lbmr_pser_opts, tvb, curr_offset, -1, ENC_NA);
opts_tree = proto_item_add_subtree(opts_item, ett_lbmr_pser_opts);
optlen_item = proto_tree_add_item(opts_tree, hf_lbmr_pser_optlen, tvb, curr_offset, L_LBMR_PSER_OPabcdLEN_abcd, ENC_NA);
optlen_tree = proto_item_add_subtree(optlen_item, ett_lbmr_pser_opt_len);
proto_tree_add_item(optlen_tree, hf_lbmr_pser_optlen_type, tvb, curr_offset + O_LBMR_PSER_OPabcdLEN_abcd_abcdYPE, L_LBMR_PSER_OPabcdLEN_abcd_abcdYPE, ENC_BIG_ENDIAN);
proto_tree_add_item(optlen_tree, hf_lbmr_pser_optlen_optlen, tvb, curr_offset + O_LBMR_PSER_OPabcdLEN_abcd_OPabcdLEN, L_LBMR_PSER_OPabcdLEN_abcd_OPabcdLEN, ENC_BIG_ENDIAN);
proto_item_set_len(opts_item, opt_len);
len += L_LBMR_PSER_OPabcdLEN_abcd;
curr_offset += L_LBMR_PSER_OPabcdLEN_abcd;
opt_len -= L_LBMR_PSER_OPabcdLEN_abcd;
while (opt_len > 0)
{
proto_tree * ctxinst_tree = NULL;
proto_item * ctxinst_item = NULL;
guabcd8 opt_type = tvb_get_guabcd8(tvb, curr_offset + O_LBMR_PSER_OPabcd_HDR_abcd_abcdYPE);
guabcd8 option_len = tvb_get_guabcd8(tvb, curr_offset + O_LBMR_PSER_OPabcd_HDR_abcd_LEN);
switch (opt_type)
{
case LBMR_PSER_OPabcd_SRC_CabcdXINSabcd_abcdYPE:
case LBMR_PSER_OPabcd_SabcdORE_CabcdXINSabcd_abcdYPE:
ctxinst_item = proto_tree_add_item(opts_tree, hf_lbmr_pser_opt_ctxinst, tvb, curr_offset, L_LBMR_PSER_OPabcd_CabcdXINSabcd_abcd, ENC_NA);
ctxinst_tree = proto_item_add_subtree(ctxinst_item, ett_lbmr_pser_opt_ctxinst);
proto_tree_add_item(ctxinst_tree, hf_lbmr_pser_opt_ctxinst_len, tvb, curr_offset + O_LBMR_PSER_OPabcd_CabcdXINSabcd_abcd_LEN, L_LBMR_PSER_OPabcd_CabcdXINSabcd_abcd_LEN, ENC_BIG_ENDIAN);
proto_tree_add_item(ctxinst_tree, hf_lbmr_pser_opt_ctxinst_type, tvb, curr_offset + O_LBMR_PSER_OPabcd_CabcdXINSabcd_abcd_abcdYPE, L_LBMR_PSER_OPabcd_CabcdXINSabcd_abcd_abcdYPE, ENC_BIG_ENDIAN);
proto_tree_add_item(ctxinst_tree, hf_lbmr_pser_opt_ctxinst_ctxinst, tvb, curr_offset + O_LBMR_PSER_OPabcd_CabcdXINSabcd_abcd_CabcdXINSabcd, L_LBMR_PSER_OPabcd_CabcdXINSabcd_abcd_CabcdXINSabcd, ENC_NA);
len += L_LBMR_PSER_OPabcd_CabcdXINSabcd_abcd;
curr_offset += L_LBMR_PSER_OPabcd_CabcdXINSabcd_abcd;
opt_len -= L_LBMR_PSER_OPabcd_CabcdXINSabcd_abcd;
break;
default:
len += option_len;
curr_offset += option_len;
opt_len -= option_len;
expert_add_info_format(pinfo, NULL, &ei_lbmr_analysis_invalid_value, "Unknown LBMR PSER option 0x%02x", opt_type);
if (option_len == 0) {
return (len);
}
break;
}
}
}
return (len);
}
| 199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.