【提成计算源码】【NBA小程序源码】【卡盟源码授权】pc28二开源码

【提成计算源码】【NBA小程序源码】【卡盟源码授权】pc28二开源码_源码二开教程

时间:2024-11-15 22:38:42 来源：免费口红机源码

1.å°ç¨åºä½ä»£ç å¼åå¹³å°ï¼
2.des算法源代码
3.å¦ä½è§£å³bus error
4.用来制作电子书的开源软件有哪些?急
5.访问注册表出错

pc28二开源码_源码二开教程

å°ç¨åºä½ä»£ç å¼åå¹³å°ï¼

è·ªæ±ä½ä»£ç å¼åæåªäºï¼

å¹´å½åå®¶ä¼ç§ä½ä»£ç å¼åå¹³å°æ±æ»çç¹ï¼

1ãå®æââé¿é

2ãç»ä¿¡Informatââåºç³åä½

3ãç±éæââç¾åº¦

4ãè½»èââç½æ

5ãå¾®æââè¾è®¯

6ãIVXå¹³å°ââäºå¨åç§æ

7ãæ´»åæ ¼ââè¡èå

8ãç®éäºââå¸è½¯

9ãæéäºââä¸ä¼æé

ãäºè¡¨ââä¹éè½¯ä»¶

ãææäºââä¹ç« ä¿¡æ¯

ãJePaaSââå¯ç¹ä¼ä¸

ãåçéæ¹ââåçè½¯ä»¶

ãAPICloudââç¨åè½¯ä»¶

ãè½»æµââææ ¡ä¿¡æ¯

ãéæ¹ç½è¡¨ââéæ¹æä¹

ãClickPaaså¹³å°ââç±æ¹æ¯ç§æ

ãJeecgBootââå½ç¬ä¿¡æ¯

ãæ°äºââå¥¥å²

ãJ2PaaSââåé¼ç§æ

ãåä¸ºäºAppCube

ãé£ä¹¦å¤ç»´è¡¨æ ¼ââåè

ãéè¶äºèç©¹ââéè¶è½¯ä»¶

ãæ³å¾®ä½ä»£ç ââæ³å¾®

ãiGIXââæµªæ½®

ãæé²¸äºââçé»çå¨

ãèåä½ä»£ç ââèåè½¯ä»¶

ãä¼ä¼´äºââä¼ä¼´æºæ§

ãè½»éªåµââéç°ä»£

ãæ°ç¿æ°æ®ââåäº¬æ°ç¿

ä¸ªå¹³å°å¨é¨çç¹å®æ¯ï¼å¸æå¯¹å¤§å®¶ææå¸®å©å~

æåªäºæ¯è¾å¥½ç¨çä½ä»£ç å¼åå¹³å°ï¼

æ¯è¾å¥½ç¨çä½ä»£ç å¼åå¹³å°æå®å¤©è½¯ä»¶ãå®æãç®éäºçã

ä¸è¬ä¼ä¸çº§ä½ä»£ç å¼åå¹³å°ï¼é½æåªäºå·ä½åè½ï¼

ä¸ãä½éªè¿ç¨

ãè¿æ¥æ°æ®æº

ãè®¾è®¡è¡¨å

ãæµç¨è®¾è®¡

ãå¾è¡¨åç°

ãç»ç»æ¶æè®¾ç½®

äºãæçè¯ä»·

ææå®ç°ãæ´ä¸ªè¿ç¨æµçï¼åºæ¬æ å¡é¡¿ï¼æäºçè§£åè°è¯ã

ä¸ãå°ç»

des算法源代码

des.h文件：

#ifndef CRYPTOPP_DES_H

#define CRYPTOPP_DES_H

#include "cryptlib.h"

#include "misc.h"

NAMESPACE_BEGIN(CryptoPP)

class DES : public BlockTransformation

{

public:

DES(const byte *userKey, CipherDir);

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const

{ DES::ProcessBlock(inoutBlock, inoutBlock);}

enum { KEYLENGTH=8, BLOCKSIZE=8};

unsigned int BlockSize() const { return BLOCKSIZE;}

protected:

static const word Spbox[8][];

SecBlock<word> k;

};

class DESEncryption : public DES

{

public:

DESEncryption(const byte * userKey)

: DES (userKey, ENCRYPTION) { }

};

class DESDecryption : public DES

{

public:

DESDecryption(const byte * userKey)

: DES (userKey, DECRYPTION) { }

};

class DES_EDE_Encryption : public BlockTransformation

{

public:

DES_EDE_Encryption(const byte * userKey)

: e(userKey, ENCRYPTION), d(userKey + DES::KEYLENGTH, DECRYPTION) { }

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const;

enum { KEYLENGTH=, BLOCKSIZE=8};

unsigned int BlockSize() const { return BLOCKSIZE;}

private:

DES e, d;

};

class DES_EDE_Decryption : public BlockTransformation

{

public:

DES_EDE_Decryption(const byte * userKey)

: d(userKey, DECRYPTION), e(userKey + DES::KEYLENGTH, ENCRYPTION) { }

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const;

enum { KEYLENGTH=, BLOCKSIZE=8};

unsigned int BlockSize() const { return BLOCKSIZE;}

private:

DES d, e;

};

class TripleDES_Encryption : public BlockTransformation

{

public:

TripleDES_Encryption(const byte * userKey)

: e1(userKey, ENCRYPTION), d(userKey + DES::KEYLENGTH, DECRYPTION),

e2(userKey + 2*DES::KEYLENGTH, ENCRYPTION) { }

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const;

enum { KEYLENGTH=, BLOCKSIZE=8};

unsigned int BlockSize() const { return BLOCKSIZE;}

private:

DES e1, d, e2;

};

class TripleDES_Decryption : public BlockTransformation

{

public:

TripleDES_Decryption(const byte * userKey)

: d1(userKey + 2*DES::KEYLENGTH, DECRYPTION), e(userKey + DES::KEYLENGTH, ENCRYPTION),

d2(userKey, DECRYPTION) { }

void ProcessBlock(const byte *inBlock, byte * outBlock) const;

void ProcessBlock(byte * inoutBlock) const;

enum { KEYLENGTH=, BLOCKSIZE=8};

unsigned int BlockSize() const { return BLOCKSIZE;}

private:

DES d1, e, d2;

};

NAMESPACE_END

#endif

des.cpp文件：

// des.cpp - modified by Wei Dai from:

* This is a major rewrite of my old public domain DES code written

* circa , which in turn borrowed heavily from Jim Gillogly's

* public domain code. I pretty much kept my key scheduling code, but

* the actual encrypt/decrypt routines are taken from from Richard

* Outerbridge's DES code as printed in Schneier's "Applied Cryptography."

* This code is in the public domain. I would appreciate bug reports and

* enhancements.

* Phil Karn KA9Q, karn@unix.ka9q.ampr.org, August .

#include "pch.h"

#include "misc.h"

#include "des.h"

NAMESPACE_BEGIN(CryptoPP)

/* Tables defined in the Data Encryption Standard documents

* Three of these tables, the initial permutation, the final

* permutation and the expansion operator, are regular enough that

* for speed, we hard-code them. They're here for reference only.

* Also, the S and P boxes are used by a separate program, gensp.c,

* to build the combined SP box, Spbox[]. They're also here just

* for reference.

#ifdef notdef

/* initial permutation IP */

static byte ip[] = {

, , , , , , , 2,

, , , , , , , 4,

, , , , , , , 6,

, , , , , , , 8,

, , , , , , 9, 1,

, , , , , , , 3,

, , , , , , , 5,

, , , , , , , 7

};

/* final permutation IP^-1 */

static byte fp[] = {

, 8, , , , , , ,

, 7, , , , , , ,

, 6, , , , , , ,

, 5, , , , , , ,

, 4, , , , , , ,

, 3, , , , , , ,

, 2, , , , , , ,

, 1, , 9, , , ,

};

/* expansion operation matrix */

static byte ei[] = {

, 1, 2, 3, 4, 5,

4, 5, 6, 7, 8, 9,

8, 9, , , , ,

, , , , , ,

, , , , , 1

};

/* The (in)famous S-boxes */

static byte sbox[8][] = {

/* S1 */

, 4, , 1, 2, , , 8, 3, , 6, , 5, 9, 0, 7,

0, , 7, 4, , 2, , 1, , 6, , , 9, 5, 3, 8,

4, 1, , 8, , 6, 2, , , , 9, 7, 3, , 5, 0,

, , 8, 2, 4, 9, 1, 7, 5, , 3, , , 0, 6, ,

/* S2 */

, 1, 8, , 6, , 3, 4, 9, 7, 2, , , 0, 5, ,

3, , 4, 7, , 2, 8, , , 0, 1, , 6, 9, , 5,

0, , 7, , , 4, , 1, 5, 8, , 6, 9, 3, 2, ,

, 8, , 1, 3, , 4, 2, , 6, 7, , 0, 5, , 9,

/* S3 */

, 0, 9, , 6, 3, , 5, 1, , , 7, , 4, 2, 8,

, 7, 0, 9, 3, 4, 6, , 2, 8, 5, , , , , 1,

, 6, 4, 9, 8, , 3, 0, , 1, 2, , 5, , , 7,

1, , , 0, 6, 9, 8, 7, 4, , , 3, , 5, 2, ,

/* S4 */

7, , , 3, 0, 6, 9, , 1, 2, 8, 5, , , 4, ,

, 8, , 5, 6, , 0, 3, 4, 7, 2, , 1, , , 9,

, 6, 9, 0, , , 7, , , 1, 3, , 5, 2, 8, 4,

3, , 0, 6, , 1, , 8, 9, 4, 5, , , 7, 2, ,

/* S5 */

2, , 4, 1, 7, , , 6, 8, 5, 3, , , 0, , 9,

, , 2, , 4, 7, , 1, 5, 0, , , 3, 9, 8, 6,

4, 2, 1, , , , 7, 8, , 9, , 5, 6, 3, 0, ,

, 8, , 7, 1, , 2, , 6, , 0, 9, , 4, 5, 3,

/* S6 */

, 1, , , 9, 2, 6, 8, 0, , 3, 4, , 7, 5, ,

, , 4, 2, 7, , 9, 5, 6, 1, , , 0, , 3, 8,

9, , , 5, 2, 8, , 3, 7, 0, 4, , 1, , , 6,

4, 3, 2, , 9, 5, , , , , 1, 7, 6, 0, 8, ,

/* S7 */

4, , 2, , , 0, 8, , 3, , 9, 7, 5, , 6, 1,

, 0, , 7, 4, 9, 1, , , 3, 5, , 2, , 8, 6,

1, 4, , , , 3, 7, , , , 6, 8, 0, 5, 9, 2,

6, , , 8, 1, 4, , 7, 9, 5, 0, , , 2, 3, ,

/* S8 */

, 2, 8, 4, 6, , , 1, , 9, 3, , 5, 0, , 7,

1, , , 8, , 3, 7, 4, , 5, 6, , 0, , 9, 2,

7, , 4, 1, 9, , , 2, 0, 6, , , , 3, 5, 8,

2, 1, , 7, 4, , 8, , , , 9, 0, 3, 5, 6,

};

/* -bit permutation function P used on the output of the S-boxes */

static byte pi[] = {

, 7, , ,

, , , ,

1, , , ,

5, , , ,

2, 8, , ,

, , 3, 9,

, , , 6,

, , 4,

};

#endif

/* permuted choice table (key) */

static const byte pc1[] = {

, , , , , , 9,

1, , , , , , ,

, 2, , , , , ,

, , 3, , , , ,

, , , , , , ,

7, , , , , , ,

, 6, , , , , ,

, , 5, , , , 4

};

/* number left rotations of pc1 */

static const byte totrot[] = {

1,2,4,6,8,,,,,,,,,,,

};

/* permuted choice key (table) */

static const byte pc2[] = {

, , , , 1, 5,

3, , , 6, , ,

, , , 4, , 8,

, 7, , , , 2,

, , , , , ,

, , , , ,

};

/* End of DES-defined tables */

/* bit 0 is left-most in byte */

static const int bytebit[] = {

,,,,,,,

};

/* Set key (initialize key schedule array) */

DES::DES(const byte *key, CipherDir dir)

: k()

{

SecByteBlock buffer(++8);

byte *const pc1m=buffer; /* place to modify pc1 into */

byte *const pcr=pc1m+; /* place to rotate pc1 into */

byte *const ks=pcr+;

int m;

for (j=0; j<; j++) { /* convert pc1 to bits of key */

l=pc1[j]-1; /* integer bit location */

m = l & ; /* find bit */

pc1m[j]=(key[l>>3] & /* find which key byte l is in */

bytebit[m]) /* and which bit of that byte */

1 : 0; /* and store 1-bit result */

}

for (i=0; i<; i++) { /* key chunk for each iteration */

memset(ks,0,8); /* Clear key schedule */

for (j=0; j<; j++) /* rotate pc1 the right amount */

pcr[j] = pc1m[(l=j+totrot[i])<(j<? : ) ? l: l-];

/* rotate left and right halves independently */

for (j=0; j<; j++){ /* select bits individually */

/* check bit that goes to ks[j] */

if (pcr[pc2[j]-1]){

/* mask it in if it's there */

l= j % 6;

ks[j/6] |= bytebit[l] >> 2;

}

/* Now convert to odd/even interleaved form for use in F */

k[2*i] = ((word)ks[0] << )

| ((word)ks[2] << )

| ((word)ks[4] << 8)

| ((word)ks[6]);

k[2*i+1] = ((word)ks[1] << )

| ((word)ks[3] << )

| ((word)ks[5] << 8)

| ((word)ks[7]);

}

if (dir==DECRYPTION) // reverse key schedule order

for (i=0; i<; i+=2)

{

std::swap(k[i], k[-2-i]);

std::swap(k[i+1], k[-1-i]);

}

/* End of C code common to both versions */

/* C code only in portable version */

// Richard Outerbridge's initial permutation algorithm

inline void IPERM(word &left, word &right)

{

word work;

work = ((left >> 4) ^ right) & 0x0f0f0f0f;

right ^= work;

left ^= work << 4;

work = ((left >> ) ^ right) & 0xffff;

right ^= work;

left ^= work << ;

work = ((right >> 2) ^ left) & 0x;

left ^= work;

right ^= (work << 2);

work = ((right >> 8) ^ left) & 0xffff;

left ^= work;

right ^= (work << 8);

right = rotl(right, 1);

work = (left ^ right) & 0xaaaaaaaa;

left ^= work;

right ^= work;

left = rotl(left, 1);

}

inline void FPERM(word &left, word &right)

{

word work;

right = rotr(right, 1);

work = (left ^ right) & 0xaaaaaaaa;

left ^= work;

right ^= work;

left = rotr(left, 1);

work = ((left >> 8) ^ right) & 0xffff;

right ^= work;

left ^= work << 8;

work = ((left >> 2) ^ right) & 0x;

right ^= work;

left ^= work << 2;

work = ((right >> ) ^ left) & 0xffff;

left ^= work;

right ^= work << ;

work = ((right >> 4) ^ left) & 0x0f0f0f0f;

left ^= work;

right ^= work << 4;

}

// Wei Dai's modification to Richard Outerbridge's initial permutation

// algorithm, this one is faster if you have access to rotate instructions

// (like in MSVC)

inline void IPERM(word &left, word &right)

{

word work;

right = rotl(right, 4U);

work = (left ^ right) & 0xf0f0f0f0;

left ^= work;

right = rotr(right^work, U);

work = (left ^ right) & 0xffff;

left ^= work;

right = rotr(right^work, U);

work = (left ^ right) & 0x;

left ^= work;

right = rotr(right^work, 6U);

work = (left ^ right) & 0xffff;

left ^= work;

right = rotl(right^work, 9U);

work = (left ^ right) & 0xaaaaaaaa;

left = rotl(left^work, 1U);

right ^= work;

}

inline void FPERM(word &left, word &right)

{

word work;

right = rotr(right, 1U);

work = (left ^ right) & 0xaaaaaaaa;

right ^= work;

left = rotr(left^work, 9U);

work = (left ^ right) & 0xffff;

right ^= work;

left = rotl(left^work, 6U);

work = (left ^ right) & 0x;

right ^= work;

left = rotl(left^work, U);

work = (left ^ right) & 0xffff;

right ^= work;

left = rotl(left^work, U);

work = (left ^ right) & 0xf0f0f0f0;

right ^= work;

left = rotr(left^work, 4U);

}

// Encrypt or decrypt a block of data in ECB mode

void DES::ProcessBlock(const byte *inBlock, byte * outBlock) const

{

word l,r,work;

#ifdef IS_LITTLE_ENDIAN

l = byteReverse(*(word *)inBlock);

r = byteReverse(*(word *)(inBlock+4));

#else

l = *(word *)inBlock;

r = *(word *)(inBlock+4);

#endif

IPERM(l,r);

const word *kptr=k;

for (unsigned i=0; i<8; i++)

{

work = rotr(r, 4U) ^ kptr[4*i+0];

l ^= Spbox[6][(work) & 0x3f]

^ Spbox[4][(work >> 8) & 0x3f]

^ Spbox[2][(work >> ) & 0x3f]

^ Spbox[0][(work >> ) & 0x3f];

work = r ^ kptr[4*i+1];

l ^= Spbox[7][(work) & 0x3f]

^ Spbox[5][(work >> 8) & 0x3f]

^ Spbox[3][(work >> ) & 0x3f]

^ Spbox[1][(work >> ) & 0x3f];

work = rotr(l, 4U) ^ kptr[4*i+2];

r ^= Spbox[6][(work) & 0x3f]

^ Spbox[4][(work >> 8) & 0x3f]

^ Spbox[2][(work >> ) & 0x3f]

^ Spbox[0][(work >> ) & 0x3f];

work = l ^ kptr[4*i+3];

r ^= Spbox[7][(work) & 0x3f]

^ Spbox[5][(work >> 8) & 0x3f]

^ Spbox[3][(work >> ) & 0x3f]

^ Spbox[1][(work >> ) & 0x3f];

}

FPERM(l,r);

#ifdef IS_LITTLE_ENDIAN

*(word *)outBlock = byteReverse(r);

*(word *)(outBlock+4) = byteReverse(l);

#else

*(word *)outBlock = r;

*(word *)(outBlock+4) = l;

#endif

}

void DES_EDE_Encryption::ProcessBlock(byte *inoutBlock) const

{

e.ProcessBlock(inoutBlock);

d.ProcessBlock(inoutBlock);

e.ProcessBlock(inoutBlock);

}

void DES_EDE_Encryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

{

e.ProcessBlock(inBlock, outBlock);

d.ProcessBlock(outBlock);

e.ProcessBlock(outBlock);

}

void DES_EDE_Decryption::ProcessBlock(byte *inoutBlock) const

{

d.ProcessBlock(inoutBlock);

e.ProcessBlock(inoutBlock);

d.ProcessBlock(inoutBlock);

}

void DES_EDE_Decryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

{

d.ProcessBlock(inBlock, outBlock);

e.ProcessBlock(outBlock);

d.ProcessBlock(outBlock);

}

void TripleDES_Encryption::ProcessBlock(byte *inoutBlock) const

{

e1.ProcessBlock(inoutBlock);

d.ProcessBlock(inoutBlock);

e2.ProcessBlock(inoutBlock);

}

void TripleDES_Encryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

{

e1.ProcessBlock(inBlock, outBlock);

d.ProcessBlock(outBlock);

e2.ProcessBlock(outBlock);

}

void TripleDES_Decryption::ProcessBlock(byte *inoutBlock) const

{

d1.ProcessBlock(inoutBlock);

e.ProcessBlock(inoutBlock);

d2.ProcessBlock(inoutBlock);

}

void TripleDES_Decryption::ProcessBlock(const byte *inBlock, byte *outBlock) const

{

d1.ProcessBlock(inBlock, outBlock);

e.ProcessBlock(outBlock);

d2.ProcessBlock(outBlock);

}

NAMESPACE_END

å¦ä½è§£å³bus error

ä¸ï¼Bus Errorç©¶ç«æ¯æä»ä¹

Bus Errorï¼å³æ»çº¿éè¯¯ã

å¼ååå ï¼

Linuxå¹³å°ä¸æ§è¡malloc()ï¼å¦ææ²¡æè¶³å¤çRAMï¼Linuxä¸æ¯è®©malloc()å¤±è´¥è¿åï¼èæ¯åå½åè¿ç¨ååSIGBUSä¿¡å·ã

SIGBUSä¸SIGSEGVä¿¡å·çä¸è¬åºå«å¦ä¸:

2) SIGSEGV(Segment fault)æå³çæéæå¯¹åºçå°åæ¯æ æå°åï¼æ²¡æç©çååå¯¹åºè¯¥å°åã

äºï¼ä¾åç¨åºï¼

1 int main(){

6 #if defined(__GNUC__)

7 # if defined(__i__)

9 __asm__("pushf/norl $0x,(%esp)/npopf");

# elif defined(__x___)

__asm__("pushf/norl $0x,(%rsp)/npopf");

# endif

#endif

short array[];

int * p = (int *) &array[1];

*p = 1;

return 1;

}

wikiä¸çä¾åï¼

http://en.wikipedia.org/wiki/Bus_error#Bus_error_example

#include <stdlib.h>

int main( int argc, char ** argv) {

int * iptr;

char * cptr;

#if defined(__GNUC__)

# if defined(__i__)

__asm__( "pushf/n orl $0x,(%esp)/n popf" ) ;

# elif defined(__x___)

__asm__( "pushf/n orl $0x,(%rsp)/n popf" ) ;

# endif

#endif

cptr = malloc( sizeof ( int ) + 1) ;

iptr = ( int * ) ++ cptr;

* iptr = ;

return 0 ;

}

$ gcc -ansi sigbus.c -o sigbus

$ ./sigbus

Bus error

$ gdb ./sigbus

(gdb) r

Program received signal SIGBUS , Bus error.

0xba in main ()

(gdb) x/i $pc

0xba <main+>: mov DWORD PTR [eax],0x2a

(gdb) p/x $eax

$1 = 0xa

(gdb) p/t $eax & (sizeof(int) - 1)

$2 = 1

ä¸ï¼ç¼è¯å¨åç¡¬ä»¶å¹³å°ç¸å³æ§

GCCæä¸ä¸ªType Attributesç¹æ§ï¼ä¾å¦å¨éäººå·¥å¯¹é½çåéåå ä¸ï¼__attribute__ ((aligned (4))); å¶æä¹å°±æ¯æå®åç§»éä¸º4çåæ°ãæ¯å¦ï¼

short array[] __attribute__ ((aligned (4)))ï¼

union {

short s;

int i;

}

用来制作电子书的软件有哪些?急

制作电子书的软件推荐使用名编辑电子杂志大师，该软件提供了放大、码源码开缩小和全屏浏览模式，教程来提高用户在阅读时候的开源体验。可以通过双击翻页书页面来进行放大和缩小，码源码开或者通过放大、教程提成计算源码缩小、开源全屏功能按钮来进行操作。码源码开

名编辑电子杂志大师可以设置背景音乐，教程并且可以选择循环播放或单曲播放等多种播放模式。开源可以设置任何喜欢的码源码开背景，设置纯色背景或者渐变色背景。教程如果觉得背景不够绚丽，开源还可以用flash动态背景。码源码开万彩信息旗下的教程名编辑电子杂志大师提供了许多免费的场景，同时也可以导入自己的flash文件作为背景。拥有卡通人物解说员助手功能，在电子杂志窗口显示卡通人物解说员助手，可以直接插入或者录制声音给解说员在相应的页面配音。点击马上开启制作之旅

想要了解更多关于制作电子书的相关信息，推荐选择万彩信息旗下的名编辑电子杂志大师。广州万彩信息技术有限公司旗下自主研发而成的名编辑电子杂志大师，是中国最专业的电子杂志制作软件。在软件发布之初，由于其操作简单、功能多样的特性，迅速受到了用户的喜爱和认可，并获得了强烈的反响。

访问注册表出错

访问注册表出错

因为每台电脑的用户不同访问权限不同

只要替换你这个 S-1-5----- 就可以导入

运行 regedit

你打开注册表找到这个项是什么数字

替换上面的数字即可导入

程序不知道怎么调，那个MBUS

驱动程序开发的一个重大难点就是不易调试。本文目的NBA小程序源码就是介绍驱动开发中常用的几种直接和间接的调试手段，它们是：

1、利用printk

2、查看OOP消息

3、利用strace

4、利用内核内置的hacking选项

5、利用ioctl方法

6、利用/proc 文件系统

7、使用kgdb

前两种如下：

一、利用printk

这是驱动开发中最朴实无华，同时也是最常用和有效的手段。scull驱动的main.c第行如下，就是使用printk进行调试的例子，这样的例子相信大家在阅读驱动源码时随处可见。

// printk(KERN_ALERT "wakeup by signal in process %d\n", current-pid);

printk的功能与我们经常在应用程序中使用的printf是一样的，不同之处在于printk可以在打印字符串前面加上内核定义的宏，例如上面例子中的KERN_ALERT（注意：宏与字符串之间没有逗号）。

#define KERN_EMERG "0"

#define KERN_ALERT "1"

#define KERN_CRIT "2"

#define KERN_ERR "3"

#define KERN_WARNING "4"

#define KERN_NOTICE "5"

#define KERN_INFO "6"

#define KERN_DEBUG "7"

#define DEFAULT_CONSOLE_LOGLEVEL 7

这个宏是用来定义需要打印的字符串的级别。值越小，级别越高。内核中有个参数用来控制是否将printk打印的字符串输出到控制台（屏幕或者/sys/log/syslog日志文件）

# cat /proc/sys/kernel/printk

6 4 1 7

第一个6表示级别高于（小于）6的消息才会被输出到控制台，第二个4表示如果调用printk时没有指定消息级别（宏）则消息的级别为4，第三个1表示接受的最高（最小）级别是1，第四个7表示系统启动时第一个6原来的初值是7。

因此，如果你发现在控制台上看不到你程序中某些printk的输出，请使用echo 8 /proc/sys/kernel/printk来解决。

在复杂驱动的开发过程中，为了调试会在源码中加入成百上千的printk语句。而当调试完毕形成最终产品的时候必然会将这些printk语句删除想想驱动的使用者而不是开发者吧。记住：己所不欲，卡盟源码授权勿施于人），这个工作量是不小的。最要命的是，如果我们将调试用的printk语句删除后，用户又报告驱动有bug，所以我们又不得不手工将这些上千条的printk语句再重新加上。oh，my god，杀了我吧。所以，我们需要一种能方便地打开和关闭调试信息的手段。哪里能找到这种手段呢？哈哈，远在天边，近在眼前。看看scull驱动或者leds驱动的源代码吧！

#define LEDS_DEBUG

#undef PDEBUG

#ifdef LEDS_DEBUG

#ifdef __KERNEL__

#define PDEBUG(fmt, args…) printk( KERN_EMERG "leds: " fmt, ## args)

#else

#define PDEBUG(fmt, args…) fprintf(stderr, fmt, ## args)

#endif

#else

#define PDEBUG(fmt, args…)

#endif

#undef PDEBUGG

#define PDEBUGG(fmt, args…)

这样一来，在开发驱动的过程中，如果想打印调试消息，我们就可以用PDEBUG("address of i_cdev is %p\n", inode-i_cdev);，如果不想看到该调试消息，就只需要简单的将PDEBUG改为PDEBUGG即可。而当我们调试完毕形成最终产品时，只需要简单地将第1行注释掉即可。

上边那一段代码中的__KERNEL__是内核中定义的宏，当我们编译内核（包括模块）时，它会被定义。当然如果你不明白代码中的…和##是什么意思的话，就请认真查阅一下gcc关于预处理部分的资料吧！如果你实在太懒不愿意去查阅的话，那就充当VC工程师把上面的豆丁文库源码代码copy到你的代码中去吧。

二、查看OOP消息

OOP意为惊讶。当你的驱动有问题，内核不惊讶才怪：嘿！小子，你干吗乱来！好吧，就让我们来看看内核是如何惊讶的。

根据faulty.c（单击下载）编译出faulty.ko，并 inod faulty.ko。执行echo yang /dev/faulty，结果内核就惊讶了。内核为什么会惊讶呢？因为faulty驱动的write函数执行了(int )0 = 0，向内存0地址写入，这是内核绝对不会容许的。

ssize_t faulty_write (struct file filp, const char __user buf, size_t count,

loff_t pos)

{

(int )0 = 0;

return 0;

}

1 Unable to handle kernel NULL pointer dereference at virtual address

2 pgd = c

3 [] pgd=, pte=, ppte=

4 Internal error: Oops: [#1] PREEMPT

5 Modules linked in: faulty scull

6 CPU: 0 Not tainted (2.6..6 #4)

7 PC is at faulty_write0×/0× [faulty]

8 LR is at vfs_write0xc4/0×

9 pc : [] lr : [] psr: a

sp : cf ip : cf fp : cf

r: c r9 : c r8 :

r7 : r6 : cf r5 : r4 : ce

r3 : cf r2 : r1 : r0 :

Flags: NzCv IRQs on FIQs on Mode SVC_ Segment user

Control: cf Table: DAC:

Process sh (pid: , stack limit = 0xc)

Stack: (0xcf to 0xc)

1f: cf cf ceb8 bfc ce ce

1f: cf cfa4 cf cffc ce

1f: cc0e4 cfa8

1fa0: cbf cfc0

1fc0: c

1fe0: bea c adb

Backtrace:

[] (faulty_write0×0/0× [faulty]) from [] (vfs_write0xc4/0×)

[] (vfs_write0×0/0×) from [] (sys_write0x4c/0×)

r7: r6:cf r5:ce r4:ce

[] (sys_write0×0/0×) from [] (ret_fast_syscall0×0/0x2c)

r8:cc0e4 r7: r6: r5: r4:

Code: e1a0cd edd ecb e3a (e)

1行惊讶的原因，也就是报告出错的原因；

2-4行是OOP信息序号；

5行是出错时内核已加载模块；

6行是发生错误的CPU序号；

7-行是发生错误的位置，以及当时CPU各个寄存器的值，这最有利于我们找出问题所在地；

行是当前进程的名字及进程ID

-行是出错时，栈内的内容

-行是栈回溯信息，可看出直到出错时的函数递进调用关系（确保CONFIG_FRAME_POINTER被定义）

行是出错指令及其附近指令的机器码，出错指令本身在小括号中

反汇编faulty.ko（ arm-linux-objdump -D faulty.ko faulty.dis ；cat faulty.dis）可以看到如下的语句如下：

c :

7c: e1a0cd mov ip, sp

: edd stmdb sp!, { fp, ip, lr, pc}

: ecb sub fp, ip, #4 ; 0×4

: e3a mov r0, #0 ; 0×0

8c: e str r0, [r0]

: eda ldmia sp, { fp, sp, pc}

定位出错位置以及获取相关信息的过程：

9 pc : [] lr : [] psr: a

[] (faulty_write0×0/0× [faulty]) from [] (vfs_write0xc4/0×)

[] (vfs_write0×0/0×) from [] (sys_write0x4c/0×)

出错代码是faulty_write函数中的第5条指令（(0xbfc-0xbfc)/=5），该函数的首地址是0xbfc，该函数总共6条指令（0×），该函数是被0xceb8的前一条指令调用的（即：函数返回地址是0xceb8。这一点可以从出错时lr的值正好等于0xceb8得到印证）。调用该函数的指令是vfs_write的第条（0xc4/4=）指令。

达到出错处的函数调用流程是：write(用户空间的系统调用)–sys_write–vfs_write–faulty_write

OOP消息不仅让我定位了出错的地方，更让我惊喜的是，它让我知道了一些秘密：1、变色pvi指标源码gcc中fp到底有何用处？2、为什么gcc编译任何函数的时候，总是要把3条看上去傻傻的指令放在整个函数的最开始？3、内核和gdb是如何知道函数调用栈顺序，并使用函数的名字而不是地址？ 4、我如何才能知道各个函数入栈的内容？哈哈，我渐渐喜欢上了让内核惊讶，那就再看一次内核惊讶吧。

执行 cat /dev/faulty，内核又再一次惊讶！

1 Unable to handle kernel NULL pointer dereference at virtual address b

2 pgd = c3a

3 [b] pgd=a, pte=, ppte=

4 Internal error: Oops: [#2] PREEMPT

5 Modules linked in: faulty

6 CPU: 0 Not tainted (2.6..6 #4)

7 PC is at vfs_read0xe0/0×

8 LR is at 0xffffffff

9 pc : [] lr : [] psr:

sp : cd9f ip : c fp : ffffffff

r: r9 : cd r8 :

r7 : r6 : ffffffff r5 : ffffffff r4 : ffffffff

r3 : ffffffff r2 : r1 : cd9f r0 :

Flags: nzCv IRQs on FIQs on Mode SVC_ Segment user

Control: cf Table: a DAC:

Process cat (pid: , stack limit = 0xcd)

Stack: (0xcd9f to 0xcda)

9f: c3ca0 c3c

9f: cd9f cd9fa4 cd9f cf cbb4

9f: befc cc0e4 cd9fa8

9fa0: cbf cf4c befc befc

9fc0: befc

9fe0: befc6c c adab0

Backtrace: invalid frame pointer 0xffffffff

Code: ebffff e e1a da (ec)

Segmentation fault

不过这次惊讶却令人大为不解。OOP竟然说出错的地方在vfs_read（要知道它可是大拿们千锤百炼的内核代码），这怎么可能？哈哈，万能的内核也不能追踪函数调用栈了，这是为什么？其实问题出在faulty_read的行，它导致入栈的r4、r5、r6、fp全部变为了0xffffffff，ip、lr的值未变，这样一来faulty_read函数能够成功返回到它的调用者——vfs_read。但是可怜的vfs_read（忠实的APTCS规则遵守者）并不知道它的r4、r5、r6已经被万恶的faulty_read改变，这样下去vfs_read命运就可想而知了——必死无疑！虽然内核很有能力，但缺少了正确的fp的帮助，它也无法追踪函数调用栈。

ssize_t faulty_read(struct file filp, char __user buf,

size_t count, loff_t pos)

{

int ret;

char stack_buf[4];

memset(stack_buf, 0xff, );

if (count 4)

count = 4;

ret = copy_to_user(buf, stack_buf, count);

if (!ret)

return count;

return ret;

}

0: e1a0cd mov ip, sp

4: edd stmdb sp!, { r4, r5, r6, fp, ip, lr, pc}

8: ecb sub fp, ip, #4 ; 0×4

c: edd sub sp, sp, #4 ; 0×4，这里为stack_buf[]在栈上分配1个字的空间，局部变量ret使用寄存器存储，因此就不在栈上分配空间了

: ebc sub r5, fp, # ; 0x1c

: e1a mov r4, r1

: e1a mov r6, r2

1c: e3aff mov r1, # ; 0xff

: e3a mov r2, # ; 0×

: e1a mov r0, r5

: ebfffffe bl //这里在调用memset

: eda ldmia sp, { r3, r4, r5, r6, fp, sp, pc}

这次OOP，深刻地认识到：

内核能力超强，但它不是，也不可能是万能的。所以即使你能力再强，也要和你的team member搞好关系，否则在关键时候你会倒霉的；

出错的是faulty_read，vfs_read却做了替罪羊。所以人不要被表面现象所迷惑，要深入看本质；

内核本来超级健壮，可是你写的驱动是内核的组成部分，由于它出错，结果整体。所以当你加入一个团队的时候一定要告诫自己，虽然你的角色也许并不重要，但你的疏忽大意将足以令整个非常牛X的团队。反过来说，当你是team leader的时候，在选团队成员的时候一定要慎重、慎重、再慎重，即使他只是一个小角色。

工商银行pOS机出现什么意思

你好，工商银行pos机错误代码设备检测到异常请联系服务商，这个是系统坏了故障了，无法使用请联系工商银行吧！

不知道中了什么病毒?求高人指点!!

识别电脑的病毒：

1、系统病毒

系统病毒的前缀为：Win、PE、Win、W、W等。这些病毒的一般公有的特性是可以感染windows操作系统的 .exe 和 .dll 文件，并通过这些文件进行传播。如CIH病毒。

2、蠕虫病毒

蠕虫病毒的前缀是：Worm。这种病毒的公有特性是通过网络或者系统漏洞进行传播，很大部分的蠕虫病毒都有向外发送带毒邮件，阻塞网络的特性。比如冲击波（阻塞网络），小邮差（发带毒邮件）等。

3、木马病毒、黑客病毒

木马病毒其前缀是：Trojan，黑客病毒前缀名一般为 Hack 。木马病毒的公有特性是通过网络或者系统漏洞进入用户的系统并隐藏，然后向外界泄露用户的信息，而黑客病毒则有一个可视的界面，能对用户的电脑进行远程控制。木马、黑客病毒往往是成对出现的，即木马病毒负责侵入用户的电脑，而黑客病毒则会通过该木马病毒来进行控制。现在这两种类型都越来越趋向于整合了。一般的木马如QQ消息尾巴木马 Trojan.QQ ，还有大家可能遇见比较多的针对网络游戏的木马病毒如 Trojan.LMir.PSW. 。这里补充一点，病毒名中有PSW或者什么PWD之类的一般都表示这个病毒有**密码的功能（这些字母一般都为“密码”的英文“password”的缩写）一些黑客程序如：网络枭雄（Hack.Nether.Client）等。

4、脚本病毒

脚本病毒的前缀是：Script。脚本病毒的公有特性是使用脚本语言编写，通过网页进行的传播的病毒，如红色代码（Script.Redlof）——可不是我们的老大代码兄哦^_^。脚本病毒还会有如下前缀：VBS、JS（表明是何种脚本编写的），如欢乐时光（VBS.Happytime）、十四日（Js.Fortnight.c.s）等。

5、宏病毒

其实宏病毒是也是脚本病毒的一种，由于它的特殊性，因此在这里单独算成一类。宏病毒的前缀是：Macro，第二前缀是：Word、Word、Excel、Excel（也许还有别的）其中之一。凡是只感染WORD及以前版本WORD文档的病毒采用Word做为第二前缀，格式是：Macro.Word；凡是只感染WORD以后版本WORD文档的病毒采用Word做为第二前缀，格式是：Macro.Word；凡是只感染EXCEL及以前版本EXCEL文档的病毒采用Excel做为第二前缀，格式是：Macro.Excel；凡是只感染EXCEL以后版本EXCEL文档的病毒采用Excel做为第二前缀，格式是：Macro.Excel，依此类推。该类病毒的公有特性是能感染OFFICE系列文档，然后通过OFFICE通用模板进行传播，如：著名的美丽莎(Macro.Melissa)。

6、后门病毒

后门病毒的前缀是：Backdoor。该类病毒的公有特性是通过网络传播，给系统开后门，给用户电脑带来安全隐患。如很多朋友遇到过的IRC后门Backdoor.IRCBot 。

7、病毒种植程序病毒

这类病毒的公有特性是运行时会从体内释放出一个或几个新的病毒到系统目录下，由释放出来的新病毒产生破坏。如：冰河播种者（Dropper.BingHe2.2C）、MSN射手(Dropper.Worm.Smibag)等。

8．破坏性程序病毒

破坏性程序病毒的前缀是：Harm。这类病毒的公有特性是本身具有好看的图标来诱惑用户点击，当用户点击这类病毒时，病毒便会直接对用户计算机产生破坏。如：格式化C盘（Harm.formatC.f）、杀手命令（Harm.Command.Killer）等。

9．玩笑病毒

玩笑病毒的前缀是：Joke。也称恶作剧病毒。这类病毒的公有特性是本身具有好看的图标来诱惑用户点击，当用户点击这类病毒时，病毒会做出各种破坏操作来吓唬用户，其实病毒并没有对用户电脑进行任何破坏。如：女鬼（Joke.Girlghost）病毒。

．捆绑机病毒

捆绑机病毒的前缀是：Binder。这类病毒的公有特性是病毒作者会使用特定的捆绑程序将病毒与一些应用程序如QQ、IE捆绑起来，表面上看是一个正常的文件，当用户运行这些捆绑病毒时，会表面上运行这些应用程序，然后隐藏运行捆绑在一起的病毒，从而给用户造成危害。如：捆绑QQ（Binder.QQPass.QQBin）、系统杀手（Binder.killsys）等。以上为比较常见的病毒前缀，有时候我们还会看到一些其他的，但比较少见，这里简单提一下：

DoS：会针对某台主机或者服务器进行DoS攻击；

Exploit：会自动通过溢出对方或者自己的系统漏洞来传播自身，或者他本身就是一个用于Hacking的溢出工具；

HackTool：黑客工具，也许本身并不破坏你的机子，但是会被别人加以利用来用你做替身去破坏别人。

你可以在查出某个病毒以后通过以上所说的方法来初步判断所中病毒的基本情况，达到知己知彼的效果。在杀毒无法自动查杀，打算采用手工方式的时候这些信息会给你很大的帮助。

landi刷卡机提示

刷卡机故障或系统需要升级。

1、landi刷卡机机显示错误，是刷卡机有小故障，需要关闭重启一下。

2、如重启后还报故障，需要专业人士维修。

pos机错误代码

POS终端号找不到。。1、无此终端号2、请求交易中终端号与应答交易中终端号不匹配3、关联交易中终端号与原始交易中终端号不匹配