int cli_vm_execute_jit(const struct cli_all_bc *bcs, struct cli_bc_ctx *ctx, const struct cli_bc_func *func)
{
UNUSEDPARAM(bcs);
UNUSEDPARAM(ctx);
UNUSEDPARAM(func);
return CL_EBYTECODE;
}
static cl_error_t post(int fd, int result, const char *virname, void *context)
{
struct clamscan_cb_data *d = context;
struct metachain *c;
char str[128];
UNUSEDPARAM(fd);
UNUSEDPARAM(result);
if (d != NULL)
c = d->chain;
if (c && c->nchains) {
print_chain(c, str, sizeof(str));
if (c->level == c->lastadd && !virname)
free(c->chains[--c->nchains]);
if (virname && !c->lastvir)
c->lastvir = c->level;
}
if (c)
c->level--;
return CL_CLEAN;
}
static inline int PERF_LOG_TRIES(int8_t acmode, int8_t bm_called, int32_t length) {
UNUSEDPARAM(acmode);
UNUSEDPARAM(bm_called);
UNUSEDPARAM(length);
return 0;
}
///-------------------------------------------------------------------------
// @brief
///-------------------------------------------------------------------------
void RotatingBlades::update( RenderInstanceTree& renderInstances, float elapsedTime, const Input& input )
{
m_angle += 25.0f*elapsedTime;
if (m_active)
{
//m_rotatingblades1.update( renderInstances, elapsedTime, m_world );
//#ifdef _DEBUG
// renderInstances.back()->m_name = L"Rotating blades 1";
//#endif
//m_rotatingblades2.update(renderInstances, elapsedTime, m_world, "Rotating blades 2");
//glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1.0f);
//glDepthMask(false);
//TextureManager& tm = TextureManager::getInstance();
//.glActiveTexture(GL_TEXTURE0);
//glEnable(GL_TEXTURE_2D);
//glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//tm.activateTexture(SpaceSim::getInstance().getstd::stringSetting("blades"));
//.glActiveTexture(GL_TEXTURE1);
//glEnable(GL_TEXTURE_2D);
//glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//tm.activateTexture(SpaceSim::getInstance().getstd::stringSetting("bladesalpha"));
//glDisable(GL_CULL_FACE);
//glEnable(GL_BLEND);
//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glEnable(GL_TEXTURE_2D);
//glPushMatrix();
//glTranslatef(m_position.x(), m_position.y(), m_position.z());
//glRotatef(m_angle, 0.0f, 0.1f, 0.0f);
//m_rotatingblades1.draw();
//m_rotatingblades2.draw();
//glPopMatrix();
//glEnable(GL_CULL_FACE);
//glDisable(GL_BLEND);
//.glClientActiveTexture(GL_TEXTURE1);
//glDisable(GL_TEXTURE_2D);
//.glClientActiveTexture(GL_TEXTURE0);
//glDisable(GL_TEXTURE_2D);
//glDepthMask(true);
//glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 0.0f);
}
//Minimap
//glPointSize(4.0f);
//glColor4fv(Color::cyan().rgba());
//glBegin(GL_POintS);
//(m_position.x(), m_position.y(), m_position.z() + 25.0f);
//glEnd();
UNUSEDPARAM(input);
UNUSEDPARAM(renderInstances);
UNUSEDPARAM(elapsedTime);
}
int cli_pcre_build(struct cli_matcher *root, long long unsigned match_limit, long long unsigned recmatch_limit, const struct cli_dconf *dconf)
{
UNUSEDPARAM(root);
UNUSEDPARAM(match_limit);
UNUSEDPARAM(recmatch_limit);
UNUSEDPARAM(dconf);
cli_errmsg("cli_pcre_build: Cannot build PCRE expression without PCRE support\n");
return CL_SUCCESS;
}
int cli_pcre_recaloff(struct cli_matcher *root, struct cli_pcre_off *data, struct cli_target_info *info, cli_ctx *ctx)
{
UNUSEDPARAM(root);
UNUSEDPARAM(info);
UNUSEDPARAM(ctx);
if (data) {
data->offset = NULL;
data->shift = NULL;
}
return CL_SUCCESS;
}
void hash_callback(int fd, unsigned long long size, const unsigned char *md5, const char *virname, void *ctx)
{
struct cb_context *c = ctx;
UNUSEDPARAM(fd);
UNUSEDPARAM(virname);
if (!c)
return;
c->virsize = size;
strncpy(c->virhash, (const char *)md5, 32);
c->virhash[32] = '\0';
}
//-------------------------------------------------------------------------
// @brief
//-------------------------------------------------------------------------
void ScorchMark::update( RenderInstanceTree& renderInstances, float elapsedTime, const Input& input )
{
m_lifetime -= elapsedTime;
//glDepthMask(FALSE);
//glEnable(GL_BLEND);
//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//TextureManager& tm = TextureManager::getInstance();
//.glActiveTexture(GL_TEXTURE0);
//glEnable(GL_TEXTURE_2D);
//if (m_playerscorch)
// tm.activateTexture(SpaceSim::getInstance().getstd::stringSetting("scorchmakerplayer"));
//else
// tm.activateTexture(SpaceSim::getInstance().getstd::stringSetting("scorchmarkgun"));
//.glActiveTexture(GL_TEXTURE1);
//glEnable(GL_TEXTURE_2D);
//tm.activateTexture(SpaceSim::getInstance().getstd::stringSetting("scorchmarkalpha"));
//glPushMatrix();
//glTranslatef(m_position.x(), m_position.y(), m_position.z());
//if (Vector3::xAxis() == m_normal)
//{
// glRotatef(-90, 0.0f, 1.0f, 0.0f);
//}
//else if (Vector3::yAxis() == m_normal)
//{
// glRotatef(90, 1.0f, 0.0f, 0.0f);
//}
//else if (-Vector3::xAxis() == m_normal)
//{
// glRotatef(90, 0.0f, 1.0f, 0.0f);
//}
//else if (-Vector3::yAxis() == m_normal)
//{
// glRotatef(-90, 1.0f, 0.0f, 0.0f);
//}
//else if (Vector3::zAxis() == m_normal)
// glRotatef(180, 0.0f, 1.0f, 0.0f);
//m_scorchmark.setColor(m_material.getDiffuse());
//m_scorchmark.draw();
//glPopMatrix();
//.glActiveTexture(GL_TEXTURE1);
//glDisable(GL_TEXTURE_2D);
//.glActiveTexture(GL_TEXTURE0);
//glDisable(GL_TEXTURE_2D);
//glDisable(GL_TEXTURE_2D);
//glDisable(GL_BLEND);
//glDepthMask(TRUE);
UNUSEDPARAM(renderInstances);
UNUSEDPARAM(input);
}
static void pppSendCommMessageInd(PppControlS * pppControl, MessageBufS * ptr)
{
U_CHAR *buf = pppControl->OutMessageContainer.Buf;
U_CHAR *inbuf = (U_CHAR *) ptr->Buf;
U_INT inLen = ptr->Length;
U_INT index = 0;
U_SHORT fcs = PPP_INITFCS;
PPP_LOG_ENTRY(MDB_pppSendCommMessageInd);
UNUSEDPARAM(fcs);
if (!pppControl->lcpXmitParams.isAcfcEnabled) {
PPP_LOG();
PPP_APPEND(buf, index, PPP_ALLSTATIONS, fcs);
PPP_APPEND(buf, index, PPP_UI, fcs);
}
PPP_APPEND(buf, index, PPP_IP, fcs);
PPP_MEMCPY(&buf[index], inbuf, inLen);
index += inLen;
pppControl->OutMessageContainer.Length = index;
PppCreateMessageFrameIp();
PppSendToCallback(pppControl, pppControl->OutFrameContainer.Buf, pppControl->OutFrameContainer.Length);
PPP_LOG_EXIT();
}
void
fileblobPartialSet(fileblob *fb, const char *fullname, const char *arg)
{
UNUSEDPARAM(arg);
if(fb->b.name)
return;
assert(fullname != NULL);
cli_dbgmsg("fileblobPartialSet: saving to %s\n", fullname);
fb->fd = open(fullname, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY|O_EXCL, 0600);
if(fb->fd < 0) {
cli_errmsg("fileblobPartialSet: unable to create file: %s\n",fullname);
return;
}
fb->fp = fdopen(fb->fd, "wb");
if(fb->fp == NULL) {
cli_errmsg("fileblobSetFilename: fdopen failed\n");
close(fb->fd);
return;
}
blobSetFilename(&fb->b, fb->ctx ? fb->ctx->engine->tmpdir : NULL, fullname);
if(fb->b.data)
if(fileblobAddData(fb, fb->b.data, fb->b.len) == 0) {
free(fb->b.data);
fb->b.data = NULL;
fb->b.len = fb->b.size = 0;
fb->isNotEmpty = 1;
}
fb->fullname = cli_strdup(fullname);
}
static int hash_match(const struct regex_matcher *rlist, const char *host, size_t hlen, const char *path, size_t plen, int *prefix_matched)
{
const char *virname;
#if 0
char s[1024];
strncpy(s, host, hlen);
strncpy(s+hlen, path, plen);
s[hlen+plen] = '\0';
cli_dbgmsg("hash lookup for: %s\n",s);
#endif
UNUSEDPARAM(prefix_matched);
if(rlist->sha256_hashes.bm_patterns) {
const char hexchars[] = "0123456789ABCDEF";
unsigned char h[65];
unsigned char sha256_dig[32];
unsigned i;
void *sha256;
sha256 = cl_hash_init("sha256");
if (!(sha256))
return CL_EMEM;
cl_update_hash(sha256, (void *)host, hlen);
cl_update_hash(sha256, (void *)path, plen);
cl_finish_hash(sha256, sha256_dig);
for(i=0;i<32;i++) {
h[2*i] = hexchars[sha256_dig[i]>>4];
h[2*i+1] = hexchars[sha256_dig[i]&0xf];
}
h[64]='\0';
cli_dbgmsg("Looking up hash %s for %s(%u)%s(%u)\n", h, host, (unsigned)hlen, path, (unsigned)plen);
#if 0
if (prefix_matched) {
if (cli_bm_scanbuff(sha256_dig, 4, &virname, NULL, &rlist->hostkey_prefix,0,NULL,NULL,NULL) == CL_VIRUS) {
cli_dbgmsg("prefix matched\n");
*prefix_matched = 1;
} else
return CL_SUCCESS;
}
#endif
if (cli_bm_scanbuff(sha256_dig, 32, &virname, NULL, &rlist->sha256_hashes,0,NULL,NULL,NULL) == CL_VIRUS) {
cli_dbgmsg("This hash matched: %s\n", h);
switch(*virname) {
case 'W':
cli_dbgmsg("Hash is whitelisted, skipping\n");
break;
case '1':
return CL_PHISH_HASH1;
case '2':
return CL_PHISH_HASH2;
default:
return CL_PHISH_HASH0;
}
}
}
return CL_SUCCESS;
}
void game::draw( void )
{
const view_data& vp = mCamPtr->view_params();
UNUSEDPARAM( vp );
application< game >::draw();
}
static void gpt_printSectors(cli_ctx *ctx, size_t sectorsize)
{
#ifdef DEBUG_GPT_PARSE
struct gpt_header phdr, shdr;
off_t ppos = 0, spos = 0;
size_t pptable_len, sptable_len, maplen;
uint64_t ptableLastLBA, stableLastLBA;
/* sector size calculation */
sectorsize = GPT_DEFAULT_SECTOR_SIZE;
maplen = (*ctx->fmap)->real_len;
ppos = 1 * sectorsize; /* sector 1 (second sector) is the primary gpt header */
spos = maplen - sectorsize; /* last sector is the secondary gpt header */
/* read in the primary and secondary gpt headers */
if (fmap_readn(*ctx->fmap, &phdr, ppos, sizeof(phdr)) != sizeof(phdr)) {
cli_dbgmsg("cli_scangpt: Invalid primary GPT header\n");
return;
}
if (fmap_readn(*ctx->fmap, &shdr, spos, sizeof(shdr)) != sizeof(shdr)) {
cli_dbgmsg("cli_scangpt: Invalid secondary GPT header\n");
return;
}
pptable_len = phdr.tableNumEntries * phdr.tableEntrySize;
sptable_len = shdr.tableNumEntries * shdr.tableEntrySize;
ptableLastLBA = (phdr.tableStartLBA + (pptable_len / sectorsize)) - 1;
stableLastLBA = (shdr.tableStartLBA + (sptable_len / sectorsize)) - 1;
gpt_parsemsg("0: MBR\n");
gpt_parsemsg("%llu: Primary GPT Header\n", phdr.currentLBA);
gpt_parsemsg("%llu-%llu: Primary GPT Partition Table\n", phdr.tableStartLBA, ptableLastLBA);
gpt_parsemsg("%llu-%llu: Usable LBAs\n", phdr.firstUsableLBA, phdr.lastUsableLBA);
gpt_parsemsg("%llu-%llu: Secondary GPT Partition Table\n", shdr.tableStartLBA, stableLastLBA);
gpt_parsemsg("%llu: Secondary GPT Header\n", phdr.backupLBA);
#else
UNUSEDPARAM(ctx);
UNUSEDPARAM(sectorsize);
return;
#endif
}
static cl_error_t pre(int fd, const char *type, void *context)
{
struct metachain *c;
struct clamscan_cb_data *d;
UNUSEDPARAM(fd);
UNUSEDPARAM(type);
if (!(context))
return CL_CLEAN;
d = (struct clamscan_cb_data *)context;
c = d->chain;
if (c == NULL)
return CL_CLEAN;
c->level++;
return CL_CLEAN;
}
///-----------------------------------------------------------------------------
///! @brief TODO enter a description
///! @remark
///-----------------------------------------------------------------------------
void MouseController::internalActionSetup(InputActions::ActionType inputAction, const tinyxml2::XMLAttribute* input)
{
UNUSEDPARAM(inputAction);
InputDefines::MouseControlDefinitions mouseDefinitions;
unsigned int inputHash = hashString(input->Value());
InputDefines::MouseControlDefinitions::MouseInput mouseInput = mouseDefinitions.FindControllerInputIdForHashId(inputHash);
m_physicalKeyToAction.insert(PhysicalInputPair(mouseInput, inputAction));
}
void *SzAlloc(void *p, size_t size)
{
UNUSEDPARAM(p);
if (size == 0)
return 0;
#ifdef _SZ_ALLOC_DEBUG
fprintf(stderr, "\nAlloc %10d bytes; count = %10d", size, g_allocCount);
g_allocCount++;
#endif
return malloc(size);
}
void *__lzma_wrap_alloc(void *unused, size_t size) {
UNUSEDPARAM(unused);
if(!size || size > CLI_MAX_ALLOCATION)
return NULL;
if(!size || size > CLI_MAX_ALLOCATION) {
cli_dbgmsg("lzma_wrap_alloc(): Attempt to allocate %lu bytes.\n", (unsigned long int) size);
return NULL;
}
return cli_calloc(1, size);
}
static void cli_untgz_cleanup(char *path, gzFile infile, FILE *outfile, int fdd)
{
UNUSEDPARAM(fdd);
cli_dbgmsg("in cli_untgz_cleanup()\n");
if (path != NULL)
free (path);
if (infile != NULL)
gzclose (infile);
if (outfile != NULL)
fclose(outfile);
}
static const void *mem_need(fmap_t *m, size_t at, size_t len, int lock) { /* WIN32 */
UNUSEDPARAM(lock);
if(!len) {
return NULL;
}
at += m->nested_offset;
if(!CLI_ISCONTAINED(0, m->real_len, at, len)) {
return NULL;
}
return (void *)((char *)m->data + at);
}
char *get_hostid(void *cbdata)
{
UNUSEDPARAM(cbdata);
if (!strcmp(hostid, "none"))
return NULL;
if (!is_valid_hostid())
return strdup(STATS_ANON_UUID);
return strdup(hostid);
}
void SzFree(void *p, void *address)
{
UNUSEDPARAM(p);
#ifdef _SZ_ALLOC_DEBUG
if (address != 0)
{
g_allocCount--;
fprintf(stderr, "\nFree; count = %10d", g_allocCount);
}
#endif
free(address);
}
/* FTW callback for scanning in non IDSESSION mode
* Returns SUCCESS or BREAK on success, CL_EXXX on error */
static int serial_callback(STATBUF *sb, char *filename, const char *path, enum cli_ftw_reason reason, struct cli_ftw_cbdata *data) {
struct client_serial_data *c = (struct client_serial_data *)data->data;
int sockd, ret;
const char *f = filename;
UNUSEDPARAM(sb);
if(chkpath(path))
return CL_SUCCESS;
c->files++;
switch(reason) {
case error_stat:
logg("!Can't access file %s\n", path);
c->errors++;
return CL_SUCCESS;
case error_mem:
logg("!Memory allocation failed in ftw\n");
c->errors++;
return CL_EMEM;
case warning_skipped_dir:
logg("^Directory recursion limit reached\n");
case warning_skipped_link:
return CL_SUCCESS;
case warning_skipped_special:
logg("^%s: Not supported file type\n", path);
c->errors++;
return CL_SUCCESS;
case visit_directory_toplev:
if(c->scantype >= STREAM)
return CL_SUCCESS;
f = path;
filename = NULL;
case visit_file:
break;
}
if((sockd = dconnect()) < 0) {
if(filename) free(filename);
c->errors++;
return CL_EOPEN;
}
ret = dsresult(sockd, c->scantype, f, &c->printok, &c->errors);
if(filename) free(filename);
closesocket(sockd);
if(ret < 0) {
c->errors++;
return CL_EOPEN;
}
c->infected += ret;
if(reason == visit_directory_toplev)
return CL_BREAK;
return CL_SUCCESS;
}
int cli_pcre_scanbuf(const unsigned char *buffer, uint32_t length, const char **virname, struct cli_ac_result **res, const struct cli_matcher *root, struct cli_ac_data *mdata, const struct cli_pcre_off *data, cli_ctx *ctx)
{
UNUSEDPARAM(buffer);
UNUSEDPARAM(length);
UNUSEDPARAM(virname);
UNUSEDPARAM(res);
UNUSEDPARAM(root);
UNUSEDPARAM(mdata);
UNUSEDPARAM(data);
UNUSEDPARAM(ctx);
cli_errmsg("cli_pcre_scanbuf: Cannot scan buffer with PCRE expression without PCRE support\n");
return CL_SUCCESS;
}
//-----------------------------------------------------------------------------
//! @brief TODO enter a description
//! @remark
//-----------------------------------------------------------------------------
void GunTurret::initialise(const ShaderInstance& shaderInstance)
{
UNUSEDPARAM(shaderInstance);
const SettingsManager& sm = getGameResource().getSettingsManager();
const ISetting<std::string>* modelString = sm.getSetting<std::string>("Guns");
if (modelString)
{
m_drawableObject = getWriteableGameResource().getModelManager().LoadModel(m_resource, shaderInstance, modelString->getData());
}
Super::initialise(shaderInstance);
}
void *SzAllocTemp(void *p, size_t size)
{
UNUSEDPARAM(p);
if (size == 0)
return 0;
#ifdef _SZ_ALLOC_DEBUG
fprintf(stderr, "\nAlloc_temp %10d bytes; count = %10d", size, g_allocCountTemp);
g_allocCountTemp++;
#ifdef _WIN32
return HeapAlloc(GetProcessHeap(), 0, size);
#endif
#endif
return malloc(size);
}
///-------------------------------------------------------------------------
// @brief
///-------------------------------------------------------------------------
void RotatingBlades::handleMessage( const MessageSystem::Message& msg )
{
UNUSEDPARAM(msg);
//const ActivationMessage& activateMsg = (const ActivationMessage&)msg;
//setActive(activateMsg.shouldActivate());
if (msg.getMessageId() == MESSAGE_ID(CreatedRenderResourceMessage))
{
const MessageSystem::CreatedRenderResourceMessage& renderResourceMsg = static_cast<const MessageSystem::CreatedRenderResourceMessage&>(msg);
renderResourceMsg.GetData();
m_renderHandle = renderResourceMsg.GetData()->m_renderResourceHandle;
//Store the render object reference we get back and the things it can do
m_initialisationDone = true;
}
}
void SzFreeTemp(void *p, void *address)
{
UNUSEDPARAM(p);
#ifdef _SZ_ALLOC_DEBUG
if (address != 0)
{
g_allocCountTemp--;
fprintf(stderr, "\nFree_temp; count = %10d", g_allocCountTemp);
}
#ifdef _WIN32
HeapFree(GetProcessHeap(), 0, address);
return;
#endif
#endif
free(address);
}
int cli_process_ooxml(cli_ctx *ctx)
{
#if HAVE_LIBXML2 && HAVE_JSON
uint32_t loff = 0;
int tmp = CL_SUCCESS;
cli_dbgmsg("in cli_process_ooxml\n");
if (!ctx) {
return CL_ENULLARG;
}
/* find "[Content Types].xml" */
tmp = unzip_search_single(ctx, "[Content_Types].xml", 18, &loff);
if (tmp == CL_ETIMEOUT) {
cli_json_parse_error(ctx->wrkproperty, "OOXML_ERROR_TIMEOUT");
return CL_ETIMEOUT;
}
else if (tmp != CL_VIRUS) {
cli_dbgmsg("cli_process_ooxml: failed to find ""[Content_Types].xml""!\n");
cli_json_parse_error(ctx->wrkproperty, "OOXML_ERROR_NO_CONTENT_TYPES");
return CL_EFORMAT;
}
cli_dbgmsg("cli_process_ooxml: found ""[Content_Types].xml"" @ %x\n", loff);
tmp = unzip_single_internal(ctx, loff, ooxml_content_cb);
if (tmp == CL_ETIMEOUT)
cli_json_parse_error(ctx->wrkproperty, "OOXML_ERROR_TIMEOUT");
else if (tmp == CL_EMEM)
cli_json_parse_error(ctx->wrkproperty, "OOXML_ERROR_OUTOFMEM");
else if (tmp == CL_EMAXSIZE)
cli_json_parse_error(ctx->wrkproperty, "OOXML_ERROR_EMAXSIZE");
else if (tmp == CL_EMAXFILES)
cli_json_parse_error(ctx->wrkproperty, "OOXML_ERROR_EMAXFILES");
return tmp;
#else
UNUSEDPARAM(ctx);
cli_dbgmsg("in cli_process_ooxml\n");
#if !HAVE_LIBXML2
cli_dbgmsg("cli_process_ooxml: libxml2 needs to enabled!\n");
#endif
#if !HAVE_JSON
cli_dbgmsg("cli_process_ooxml: libjson needs to enabled!\n");
#endif
return CL_SUCCESS;
#endif
}
/*ARGSUSED*/
void
blobSetFilename(blob *b, const char *dir, const char *filename)
{
assert(b != NULL);
assert(b->magic == BLOBCLASS);
assert(filename != NULL);
UNUSEDPARAM(dir);
cli_dbgmsg("blobSetFilename: %s\n", filename);
if(b->name)
free(b->name);
b->name = cli_strdup(filename);
if(b->name)
sanitiseName(b->name);
}
static void chapSendAuthSuccessOrFail(PppControlS *pppControl, U_CHAR success_or_fail_code)
{
const char *message[] = { "Authentication Successful", "Authentication Failed" };
char *pMessage = (char *)message[success_or_fail_code - CHAP_AUTHENTICATE_SUCCESS];
U_CHAR *buf = pppControl->OutMessageContainer.Buf;
U_INT index = 0;
U_INT lenIndex;
U_SHORT len = PPP_HDRLEN;
U_SHORT fcs = PPP_INITFCS;
UNUSEDPARAM(fcs);
if (!pppControl->lcpXmitParams.isAcfcEnabled) {
PPP_APPEND(buf, index, PPP_ALLSTATIONS, fcs);
PPP_APPEND(buf, index, PPP_UI, fcs);
}
PPP_APPEND_SHORT(buf, index, PPP_CHAP, fcs);
PPP_APPEND(buf, index, success_or_fail_code, fcs);
PPP_APPEND(buf, index, pppControl->LastXmitId++, fcs);
lenIndex = index;
index += 2;
while (*pMessage != '\0') {
PPP_APPEND(buf, index, *pMessage, fcs);
pMessage++;
len++;
}
PPP_APPEND_SHORT(buf, lenIndex, len, fcs);
PPP_APPEND_FCS(buf, index, fcs);
pppControl->OutMessageContainer.Length = index;
PppCreateMessageFrame();
PppSendToCallback(pppControl, pppControl->OutFrameContainer.Buf, pppControl->OutFrameContainer.Length);
}