3 Copyright (c) 1998-2001 Klaus P. Gerlicher
22 15-Nov-2000: general cleanup of source files
26 This file may be distributed under the terms of the GNU Public License.
30 ////////////////////////////////////////////////////
38 ////////////////////////////////////////////////////
43 char tempFlowChanges[256];
45 //PMADDRESS_SPACE my_init_mm=NULL;
47 ULONG TwoPagesForPhysMem[2*_PAGE_SIZE];
49 // scancode to ASCII table
50 SCANTOASCII ucScanToAscii_DE[]=
53 {16,'q'},{17,'w'},{18,'e'},{19,'r'},{20,'t'},
54 {21,'z'},{22,'u'},{23,'i'},{24,'o'},{25,'p'},
55 {30,'a'},{31,'s'},{32,'d'},{33,'f'},{34,'g'},
56 {35,'h'},{36,'j'},{37,'k'},{38,'l'},
57 {44,'y'},{45,'x'},{46,'c'},{47,'v'},{48,'b'},
59 {2,'1'},{3,'2'},{4,'3'},{ 5,'4'},{ 6,'5'},
60 {7,'6'},{8,'7'},{9,'8'},{10,'9'},{11,'0'},
61 {12,'ß'}, // 239 = ß
62 {0x39,' '},{0x35,'-'},{0x34,'.'},{0x1b,'+'},
66 SCANTOASCII ucShiftScanToAscii_DE[]=
68 // German keyboard SHIFTED
69 {16,'Q'},{17,'W'},{18,'E'},{19,'R'},{20,'T'},
70 {21,'Z'},{22,'U'},{23,'I'},{24,'O'},{25,'P'},
71 {30,'A'},{31,'S'},{32,'D'},{33,'F'},{34,'G'},
72 {35,'H'},{36,'J'},{37,'K'},{38,'L'},
73 {44,'Y'},{45,'X'},{46,'C'},{47,'V'},{48,'B'},
75 {2,'!'},{3,'\"'}, // " // (fixes mc syntax highlighting)
76 {4,'@'}, // is pragraph sign on keyboard
78 {7,'&'},{8,'/'},{9,'('},{10,')'},{11,'='},
80 {0x39,' '},{0x35,'_'},{0x34,':'},{0x1b,'*'},
84 SCANTOASCII ucScanToAscii_US[]=
87 {16,'q'},{17,'w'},{18,'e'},{19,'r'},
88 {20,'t'},{21,'y'},{22,'u'},{23,'i'},
89 {24,'o'},{25,'p'},{30,'a'},{31,'s'},
90 {32,'d'},{33,'f'},{34,'g'},{35,'h'},
91 {36,'j'},{37,'k'},{38,'l'},{44,'z'},
92 {45,'x'},{46,'c'},{47,'v'},{48,'b'},
93 {49,'n'},{50,'m'},{2,'1'},{3,'2'},
94 {4,'3'},{5,'4'},{6,'5'},{7,'6'},
95 {8,'7'},{9,'8'},{10,'9'},{11,'0'},{12,'-'},
96 {0x39,' '},{0x35,'/'},{0x34,'.'},{0x1b,']'},
97 {0x1a,'['},{0x33,','},{0x27,';'},{0x0d,'='},
98 {0x2b,'\\'},{0x28,'\''},{0x29,'`'},
102 SCANTOASCII ucShiftScanToAscii_US[]=
104 // US keyboard SHIFTED
105 {16,'Q'},{17,'W'},{18,'E'},{19,'R'},
106 {20,'T'},{21,'Y'},{22,'U'},{23,'I'},
107 {24,'O'},{25,'P'},{30,'A'},{31,'S'},
108 {32,'D'},{33,'F'},{34,'G'},{35,'H'},
109 {36,'J'},{37,'K'},{38,'L'},{44,'Z'},
110 {45,'X'},{46,'C'},{47,'V'},{48,'B'},
111 {49,'N'},{50,'M'},{2,'!'},{3,'@'},
112 {4,'#'},{5,'$'},{6,'%'},{7,'^'},
113 {8,'&'},{9,'*'},{10,'('},{11,')'},{12,'_'},
114 {0x39,' '},{0x35,'?'},{0x34,'>'},{0x1b,'}'},
115 {0x1a,'{'},{0x33,'<'},{0x27,':'},{0x0d,'+'},
116 {0x2b,'|'},{0x28,'\"'},{0x29,'~'},
121 SCANTOASCII ucScanToAscii_DK[]=
124 {16,'q'},{17,'w'},{18,'e'},{19,'r'},
125 {20,'t'},{21,'y'},{22,'u'},{23,'i'},
126 {24,'o'},{25,'p'},{30,'a'},{31,'s'},
127 {32,'d'},{33,'f'},{34,'g'},{35,'h'},
128 {36,'j'},{37,'k'},{38,'l'},{44,'z'},
129 {45,'x'},{46,'c'},{47,'v'},{48,'b'},
130 {49,'n'},{50,'m'},{2,'1'},{3,'2'},
131 {4,'3'},{5,'4'},{6,'5'},{7,'6'},
132 {8,'7'},{9,'8'},{10,'9'},{11,'0'},{12,'+'},
133 {0x39,' '},{0x35,'-'},{0x34,'.'},{0x1b,'¨'},
134 {0x1a,'å'},{0x33,','},{0x27,'æ'},{0x0d,'´'},
135 {0x2b,'\''},{0x28,'ø'},{0x29,' '},
139 SCANTOASCII ucShiftScanToAscii_DK[]=
141 // Danish keyboard SHIFTED
142 {16,'Q'},{17,'W'},{18,'E'},{19,'R'},
143 {20,'T'},{21,'Y'},{22,'U'},{23,'I'},
144 {24,'O'},{25,'P'},{30,'A'},{31,'S'},
145 {32,'D'},{33,'F'},{34,'G'},{35,'H'},
146 {36,'J'},{37,'K'},{38,'L'},{44,'Z'},
147 {45,'X'},{46,'C'},{47,'V'},{48,'B'},
148 {49,'N'},{50,'M'},{2,'!'},{3,'"'},
149 {4,'#'},{5,'¤'},{6,'%'},{7,'&'},
150 {8,'/'},{9,'('},{10,')'},{11,'='},{12,'?'},
151 {0x39,' '},{0x35,'_'},{0x34,':'},{0x1b,'^'},
152 {0x1a,'Å'},{0x33,';'},{0x27,'Æ'},{0x0d,'`'},
153 {0x2b,'*'},{0x28,'Ø'},{0x29,'§'},
157 SCANTOASCII ucAltScanToAscii_DK[]=
159 // Danish keyboard ALTED
160 {16,' '},{17,' '},{18,' '},{19,' '},
161 {20,' '},{21,' '},{22,' '},{23,' '},
162 {24,' '},{25,' '},{30,' '},{31,' '},
163 {32,' '},{33,' '},{34,' '},{35,' '},
164 {36,' '},{37,' '},{38,' '},{44,' '},
165 {45,' '},{46,' '},{47,' '},{48,' '},
166 {49,' '},{50,' '},{2,' '},{3,'@'},
167 {4,'£'},{5,'$'},{6,'
\80'},{7,' '},
168 {8,'{'},{9,'['},{10,']'},{11,'}'},{12,' '},
169 {0x39,' '},{0x35,' '},{0x34,' '},{0x1b,'~'},
170 {0x1a,' '},{0x33,' '},{0x27,' '},{0x0d,'|'},
171 {0x2b,' '},{0x28,' '},{0x29,' '},
175 KEYBOARD_LAYOUT ucKeyboard[]=
177 {"de", ucScanToAscii_DE, ucShiftScanToAscii_DE, NULL},
178 {"us", ucScanToAscii_US, ucShiftScanToAscii_US, NULL},
179 {"dk", ucScanToAscii_DK, ucShiftScanToAscii_DK, ucAltScanToAscii_DK},
180 {NULL, NULL, NULL, NULL}
183 PKEYBOARD_LAYOUT CurrentKeyboard = NULL;
186 ////////////////////////////////////////////////////
190 //*************************************************************************
191 // GetKeyboardLayout()
193 //*************************************************************************
194 PKEYBOARD_LAYOUT GetKeyboardLayout()
196 if (CurrentKeyboard == NULL)
198 CurrentKeyboard = &ucKeyboard[kbUS];
201 return CurrentKeyboard;
204 //*************************************************************************
205 // SetKeyboardLayoutByName()
207 //*************************************************************************
208 PKEYBOARD_LAYOUT SetKeyboardLayoutByName(LPSTR Name)
213 for(i=0;ucKeyboard[i].name != NULL;i++)
215 if(PICE_strcmpi(ucKeyboard[i].name, Name) == 0)
217 CurrentKeyboard = &ucKeyboard[i];
218 return CurrentKeyboard;
221 return GetKeyboardLayout();
224 //*************************************************************************
227 //*************************************************************************
228 void PICE_memset(void* p,unsigned char c,int sz)
230 unsigned char *p2 = (unsigned char *)p;
235 //*************************************************************************
238 //*************************************************************************
239 void PICE_memcpy(void* t,void* s,int sz)
244 //*************************************************************************
247 //*************************************************************************
248 BOOLEAN PICE_isprint(char c)
250 BOOLEAN bResult = FALSE;
252 if((ULONG)c>=0x20 && (ULONG)c<=0x7f)
258 //*************************************************************************
261 //*************************************************************************
262 char* PICE_strchr(char* s,char c)
264 while(IsAddressValid((ULONG)s) && *s)
271 if(!IsAddressValid((ULONG)s) )
273 DPRINT((0,"PICE_strchr(): ********************\n"));
274 DPRINT((0,"PICE_strchr(): EXCEPTION @ %.8X\n",(ULONG)s));
275 DPRINT((0,"PICE_strchr(): ********************\n"));
282 //*************************************************************************
285 //*************************************************************************
286 char* PICE_strncpy(char* s1,char* s2,int len)
288 ULONG len2 = PICE_strlen(s2);
291 PICE_memcpy(s1,s2,len2+1);
293 PICE_memcpy(s1,s2,len);
298 //*************************************************************************
301 //*************************************************************************
302 char* PICE_strcpy(char* s1,char* s2)
304 ULONG len2 = PICE_strlen(s2);
306 PICE_memcpy(s1,s2,len2+1);
311 //*************************************************************************
314 //*************************************************************************
315 char* PICE_strcat(char* s1,char* s2)
317 ULONG len1 = PICE_strlen(s1);
318 ULONG len2 = PICE_strlen(s2);
320 PICE_memcpy(&s1[len1],s2,len2+1);
325 //*************************************************************************
328 //*************************************************************************
329 char PICE_toupper(char c)
337 int PICE_isdigit( int c )
339 return ((c>=0x30) && (c<=0x39));
342 int PICE_isxdigit( int c )
344 return (PICE_isdigit(c) || ((c>=0x41) && (c<=0x46)) || ((c>=0x61) && (c<=0x66)));
347 int PICE_islower( int c )
349 return ((c>=0x61) && (c<=0x7a));
352 int PICE_isalpha( int c )
354 return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
357 //*************************************************************************
360 // my version of strncmpi()
361 //*************************************************************************
362 ULONG PICE_strncmpi(char* s1,char* s2,ULONG len)
367 IsAddressValid((ULONG)s1) && *s1 && // not end of string
368 IsAddressValid((ULONG)s2) && *s2 && // not end of string
369 PICE_toupper(*s1)==PICE_toupper(*s2) ) // char are the same except case
375 // strings same length
382 //*************************************************************************
385 // my version of strcmp()
386 //*************************************************************************
387 ULONG PICE_strcmpi(char* s1,char* s2)
391 while(IsAddressValid((ULONG)s1) && *s1 && // not end of string
392 IsAddressValid((ULONG)s2) && *s2 && // not end of string
393 PICE_toupper(*s1)==PICE_toupper(*s2) ) // char are the same except case
398 // strings same length
405 //*************************************************************************
408 // my version of strcmp()
409 //*************************************************************************
410 ULONG PICE_strcmp(char* s1,char* s2)
414 while(IsAddressValid((ULONG)s1) && *s1 && // not end of string
415 IsAddressValid((ULONG)s2) && *s2 && // not end of string
421 // strings same length
428 //*************************************************************************
431 // compare function names ignoring decorations:
432 // leading '_' or '@" and trailing "@xx"
433 //*************************************************************************
434 ULONG PICE_fncmp(char* s1,char* s2)
438 if( IsAddressValid((ULONG)s1) && (*s1 == '_' || *s1 == '@'))
441 if( IsAddressValid((ULONG)s2) && (*s2 == '_' || *s2 == '@'))
444 while(IsAddressValid((ULONG)s1) && *s1 && // not end of string
445 IsAddressValid((ULONG)s2) && *s2 )
447 if( (*s1 != *s2) || *s1=='@' || *s2=='@' )
452 // strings same length
453 if((*s1==0 || *s1=='@') && (*s2==0 || *s2 =='@')){
459 //*************************************************************************
462 // compare function names ignoring decorations:
463 // leading '_' or '@" and trailing "@xx" . Decorations are included in total length.
464 //*************************************************************************
465 ULONG PICE_fnncmp(char* s1,char* s2, ULONG len)
468 ULONG len1 = len, len2 = len;
470 if( IsAddressValid((ULONG)s1) && (*s1 == '_' || *s1 == '@')){
475 if( IsAddressValid((ULONG)s2) && (*s2 == '_' || *s2 == '@')){
480 while(len1 && len2 && IsAddressValid((ULONG)s1) && *s1 && // not end of string
481 IsAddressValid((ULONG)s2) && *s2 )
483 if( (*s1 != *s2) || *s1=='@' || *s2=='@' )
490 // strings are the same length
491 if((*s1=='\0' || *s1=='@') && (*s2=='\0' || *s2 =='@')){
497 wchar_t PICE_towlower(wchar_t c)
499 if ( c>=L'A' && c<=L'Z' )
500 return (c - (L'A' - L'a'));
504 ULONG PICE_wcsicmp(WCHAR* s1, WCHAR* s2)
508 while(IsAddressValid((ULONG)s1) && *s1 && // not end of string
509 IsAddressValid((ULONG)s2) && *s2 && // not end of string
510 PICE_towlower(*s1)==PICE_towlower(*s2) ) // char are the same except case
515 // strings same length
522 //*************************************************************************
525 // my version of strrev()
526 //*************************************************************************
527 char* PICE_strrev(char* s)
529 ULONG i,j,len=PICE_strlen(s)-1;
532 for(i=0,j=len;i<j;i++,j--)
534 c=s[i]; s[i]=s[j]; s[j]=c;
540 //*************************************************************************
543 // my version of strlen()
545 // does a page validity check on every character in th string
546 //*************************************************************************
547 USHORT PICE_strlen(const char* s)
551 for(i=0;IsAddressValid((ULONG)&s[i]) && s[i]!=0 && i<_PAGE_SIZE;i++);
553 if(IsAddressValid((ULONG)&s[i]) && s[i]==0)
559 WCHAR * PICE_wcscpy(WCHAR * str1,const WCHAR * str2)
563 for (; (*str1 = *str2); ++str2, ++str1);
568 //*************************************************************************
571 // separates module name from path
572 //*************************************************************************
573 LPSTR GetShortName(LPSTR p)
577 // scan backwards till backslash or start
578 for(i=PICE_strlen(p);p[i]!='\\' && &p[i]!=p;i--);
579 // it's not start, inc. counter
582 // return section of string containing mod name
586 //*************************************************************************
589 // copy wide string to ANSI string
590 //*************************************************************************
591 void CopyWideToAnsi(LPSTR pAnsi,PWSTR pWide)
595 for(j=0;pWide[j]!=0;j++)
597 if((char)(pWide[j]>>8)==0)
598 pAnsi[j]=(char)(pWide[j]);
607 //*************************************************************************
610 //*************************************************************************
611 BOOLEAN IsAddressValid(ULONG address)
615 BOOLEAN bResult = FALSE;
617 address &= (~(_PAGE_SIZE-1));
619 pPGD = ADDR_TO_PDE(address);
620 if(pPGD && ((*pPGD)&_PAGE_PRESENT))
623 if(!((*pPGD)&_PAGE_4M))
625 pPTE = ADDR_TO_PTE(address);
628 bResult = (*pPTE)&(_PAGE_PRESENT | _PAGE_PSE);
642 //*************************************************************************
643 // IsAddressWriteable()
646 // TRUE if adress/page is writeable
647 // FALSE if adress/page is not writeable
649 //*************************************************************************
650 BOOLEAN IsAddressWriteable(ULONG address)
655 //address &= (~(_PAGE_SIZE-1));
656 pPGD = ADDR_TO_PDE(address);
657 if(pPGD && ((*pPGD)&_PAGE_PRESENT))
660 if(!((*pPGD)&_PAGE_4M))
662 if(!((*pPGD) & _PAGE_RW))
665 pPTE = ADDR_TO_PTE(address);
668 if( ((*pPTE)&(_PAGE_PRESENT | _PAGE_PSE)) &&
669 ((*pPTE) & _PAGE_RW))
677 return ((*pPGD) & _PAGE_RW);
684 //*************************************************************************
685 // SetAddressWriteable()
687 //*************************************************************************
688 BOOLEAN SetAddressWriteable(ULONG address,BOOLEAN bSet)
693 //address &= (~(_PAGE_SIZE-1));
695 pPGD = ADDR_TO_PDE(address);
696 if(pPGD && ((*pPGD)&_PAGE_PRESENT))
699 if(!((*pPGD)&_PAGE_4M))
701 pPTE = ADDR_TO_PTE(address);
704 if( (*pPTE)&(_PAGE_PRESENT | _PAGE_PSE) )
730 //*************************************************************************
733 // scan range for page present
734 //*************************************************************************
735 BOOLEAN IsRangeValid(ULONG Addr,ULONG Length)
737 ULONG i,NumPages,PageNum;
739 // need to only touch one byte per page
740 // calculate PICE_number of pages to touch
741 NumPages=(Length+(_PAGE_SIZE-1))>>12;
743 // calculate PICE_number of page
744 PageNum=Addr>>PAGE_SHIFT;
746 // touch all pages containing range
747 for(i=0;i<NumPages;i++)
749 // if any one page is invalid range is invalid
750 if(!IsAddressValid((ULONG)((PageNum+i)*_PAGE_SIZE)) )
757 //*************************************************************************
760 // return flat address of GDT
761 //*************************************************************************
769 __asm__("sgdt %0;":"=m" (gdtr));
770 pGdt=(PGDT)(((ULONG)(gdtr[1]<<16))|((ULONG)(gdtr[0]>>16)));
777 //*************************************************************************
778 // GetLinearAddress()
780 // return flat address for SEGMENT:OFFSET
781 //*************************************************************************
782 ULONG GetLinearAddress(USHORT Segment,ULONG Offset)
787 USHORT OriginalSegment=Segment;
791 pSel=(struct tagDESCRIPTOR*)&Segment;
795 DPRINT((0,"GetLinearAddress(): pGDT = %.8X\n",pGdt));
796 DPRINT((0,"GetLinearAddress(): original Segment:Offset = %.4X:%.8X\n",Segment,Offset));
798 // see if segment selector is in LDT
801 DPRINT((0,"GetLinearAddress(): Segment is in LDT\n"));
809 DPRINT((0,"GetLinearAddress(): no LDT\n"));
811 pGdt=(PGDT)((pGdt[pSel->Val].Base_31_24<<24)|
812 (pGdt[pSel->Val].Base_23_16<<16)|
813 (pGdt[pSel->Val].Base_15_0));
814 if(!IsRangeValid((ULONG)pGdt,0x8) )
825 DPRINT((0,"GetLinearAddress(): Segment:Offset = %.4X:%.8X\n",Segment,Offset));
826 result=pGdt[OriginalSegment>>3].Base_15_0|
827 (pGdt[OriginalSegment>>3].Base_23_16<<16)|
828 (pGdt[OriginalSegment>>3].Base_31_24<<24);
831 DPRINT((0,"GetLinearAddress(%.4X:%.8X)=%.8X\n",OriginalSegment,Offset,result));
838 //*************************************************************************
841 // place RUNNING message
842 //*************************************************************************
843 void ShowRunningMsg(void)
847 SetForegroundColor(COLOR_TEXT);
848 SetBackgroundColor(COLOR_CAPTION);
849 ClrLine(wWindow[OUTPUT_WINDOW].y+wWindow[OUTPUT_WINDOW].cy);
850 PutChar(" Reactos is running... (Press CTRL-D to stop) ",1,wWindow[OUTPUT_WINDOW].y+wWindow[OUTPUT_WINDOW].cy);
856 //*************************************************************************
859 // place STOPPED message
860 //*************************************************************************
861 void ShowStoppedMsg(void)
865 SetForegroundColor(COLOR_TEXT);
866 SetBackgroundColor(COLOR_CAPTION);
867 ClrLine(wWindow[OUTPUT_WINDOW].y+wWindow[OUTPUT_WINDOW].cy);
868 PutChar(" Stopped... (Type 'x' to continue) ",1,wWindow[OUTPUT_WINDOW].y+wWindow[OUTPUT_WINDOW].cy);
874 //*************************************************************************
875 // SetHardwareBreakPoint()
877 //*************************************************************************
878 void SetHardwareBreakPoint(ULONG ulAddress,ULONG ulReg)
881 ULONG enable_mask = 0x3;
883 DPRINT((0,"SetHardwareBreakPoint(%x,DR%x)\n",ulAddress,ulReg));
885 enable_mask <<= (ulReg*2);
888 DPRINT((0,"mask = %x\n",mask));
892 xorl %%eax,%%eax\n\t \
893 mov %%eax,%%dr6\n\t \
894 mov %%dr7,%%eax\n\t \
896 mov %%eax,%%dr7\n\t \
908 mov %%eax,%%dr0\n\t \
918 mov %%eax,%%dr1\n\t \
928 mov %%eax,%%dr2\n\t \
938 mov %%eax,%%dr3\n\t \
947 //*************************************************************************
948 // SetHardwareBreakPoints()
950 // install HW breakpoints
951 //*************************************************************************
952 void SetHardwareBreakPoints(void)
956 ULONG LinAddr0,LinAddr1,LinAddr2,LinAddr3;
957 PULONG LinAddr[4]={&LinAddr0,&LinAddr1,&LinAddr2,&LinAddr3};
961 // cancel all debug activity
969 for(mask=0,i=0;i<4;i++)
972 if(Bp[i].Active && Bp[i].Used && !Bp[i].Virtual)
975 *LinAddr[3-i]=Bp[i].LinearAddress;
976 DPRINT((0,"breakpoint %u at %.8X\n",i,Bp[i].LinearAddress));
984 andl $0x000000FF,%%eax\n\t \
985 orl $0x300,%%eax\n\t \
986 mov %%eax,%%dr7\n\t \
988 mov %%eax,%%dr0\n\t \
990 mov %%eax,%%dr1\n\t \
992 mov %%eax,%%dr2\n\t \
994 mov %%eax,%%dr3\n\t \
997 :"m" (mask),"m" (LinAddr0),"m" (LinAddr1),"m" (LinAddr2),"m" (LinAddr3));
1003 //*************************************************************************
1004 // IsCallInstrAtEIP()
1006 // check if instruction at CS:EIP changes program flow
1007 //*************************************************************************
1008 BOOLEAN IsCallInstrAtEIP(void)
1011 BOOLEAN result=FALSE;
1014 DPRINT((0,"IsCallInstrAtEIP()\n"));
1016 linear=(PUCHAR)GetLinearAddress(CurrentCS,CurrentEIP);
1017 if(IsRangeValid((ULONG)linear,2))
1019 if(*linear== 0xE8 || // call
1020 (*linear== 0xFF && ( ((*(linear+1)>>3)&0x7)==0x2 || ((*(linear+1)>>3)&0x7)==0x3) ) || // call
1021 *linear== 0x9A || // call
1022 *linear== 0xF2 || // REP
1023 *linear== 0xF3) // REP
1033 //*************************************************************************
1036 // check if instruction at CS:EIP is a return instruction
1037 //*************************************************************************
1038 BOOLEAN IsRetAtEIP(void)
1041 BOOLEAN bResult = FALSE;
1044 DPRINT((0,"IsRetAtEIP()\n"));
1046 linear=(PUCHAR)GetLinearAddress(CurrentCS,CurrentEIP);
1054 case 0xcf: // IRET/IRETD
1064 //*************************************************************************
1067 // display CPU EFLAGS as string
1068 //*************************************************************************
1069 LPSTR VisualizeFlags(ULONG EFlags)
1071 static UCHAR FlagNames[]={'c',0,'p',0,'a',0,'z','s','t','i','d','o'};
1073 static char temp[32];
1075 for(j=0,i=0;i<sizeof(FlagNames);i++)
1080 temp[j++] = PICE_toupper(FlagNames[i]);
1082 temp[j++] = FlagNames[i];
1092 //*************************************************************************
1095 // display CPU registers
1096 //*************************************************************************
1097 void DisplayRegs(void)
1099 char tempDisplayRegs[48];
1103 // Clear(REGISTER_WINDOW);
1104 Home(REGISTER_WINDOW);
1106 Print(REGISTER_WINDOW,"EAX=");
1107 PICE_sprintf(tempDisplayRegs,"%.8X",CurrentEAX);
1108 if(OldEAX!=CurrentEAX)
1110 SetForegroundColor(WHITE);
1112 Print(REGISTER_WINDOW,tempDisplayRegs);
1113 if(OldEAX!=CurrentEAX)
1119 Print(REGISTER_WINDOW," EBX=");
1120 PICE_sprintf(tempDisplayRegs,"%.8X",CurrentEBX);
1121 if(OldEBX!=CurrentEBX)
1123 SetForegroundColor(WHITE);
1125 Print(REGISTER_WINDOW,tempDisplayRegs);
1126 if(OldEBX!=CurrentEBX)
1132 Print(REGISTER_WINDOW," ECX=");
1133 PICE_sprintf(tempDisplayRegs,"%.8X",CurrentECX);
1134 if(OldECX!=CurrentECX)
1136 SetForegroundColor(WHITE);
1138 Print(REGISTER_WINDOW,tempDisplayRegs);
1139 if(OldECX!=CurrentECX)
1145 Print(REGISTER_WINDOW," EDX=");
1146 PICE_sprintf(tempDisplayRegs,"%.8X",CurrentEDX);
1147 if(OldEDX!=CurrentEDX)
1149 SetForegroundColor(COLOR_HILITE);
1151 Print(REGISTER_WINDOW,tempDisplayRegs);
1152 if(OldEDX!=CurrentEDX)
1158 Print(REGISTER_WINDOW," ESI=");
1159 PICE_sprintf(tempDisplayRegs,"%.8X",CurrentESI);
1160 if(OldESI!=CurrentESI)
1162 SetForegroundColor(COLOR_HILITE);
1164 Print(REGISTER_WINDOW,tempDisplayRegs);
1165 if(OldESI!=CurrentESI)
1171 Print(REGISTER_WINDOW," EDI=");
1172 PICE_sprintf(tempDisplayRegs,"%.8X\n",CurrentEDI);
1173 if(OldEDI!=CurrentEDI)
1175 SetForegroundColor(COLOR_HILITE);
1177 Print(REGISTER_WINDOW,tempDisplayRegs);
1178 if(OldEDI!=CurrentEDI)
1184 Print(REGISTER_WINDOW,"EBP=");
1185 PICE_sprintf(tempDisplayRegs,"%.8X",CurrentEBP);
1186 if(OldEBP!=CurrentEBP)
1188 SetForegroundColor(COLOR_HILITE);
1190 Print(REGISTER_WINDOW,tempDisplayRegs);
1191 if(OldEBP!=CurrentEBP)
1197 Print(REGISTER_WINDOW," ESP=");
1198 PICE_sprintf(tempDisplayRegs,"%.8X",CurrentESP);
1199 if(OldESP!=CurrentESP)
1201 SetForegroundColor(COLOR_HILITE);
1203 Print(REGISTER_WINDOW,tempDisplayRegs);
1204 if(OldESP!=CurrentESP)
1210 Print(REGISTER_WINDOW," EIP=");
1211 PICE_sprintf(tempDisplayRegs,"%.8X",CurrentEIP);
1212 if(OldEIP!=CurrentEIP)
1214 SetForegroundColor(COLOR_HILITE);
1216 Print(REGISTER_WINDOW,tempDisplayRegs);
1217 if(OldEIP!=CurrentEIP)
1223 Print(REGISTER_WINDOW," EFLAGS=");
1224 PICE_sprintf(tempDisplayRegs,"%.8X",CurrentEFL);
1225 if(OldEFL!=CurrentEFL)
1227 SetForegroundColor(COLOR_HILITE);
1229 Print(REGISTER_WINDOW,tempDisplayRegs);
1230 if(OldEFL!=CurrentEFL)
1236 PICE_sprintf(tempDisplayRegs," %s\n",VisualizeFlags(CurrentEFL));
1237 Print(REGISTER_WINDOW,tempDisplayRegs);
1240 Print(REGISTER_WINDOW,"CS=");
1241 PICE_sprintf(tempDisplayRegs,"%.4X",CurrentCS);
1242 if(OldCS!=CurrentCS)
1244 SetForegroundColor(COLOR_HILITE);
1246 Print(REGISTER_WINDOW,tempDisplayRegs);
1247 if(OldCS!=CurrentCS)
1253 Print(REGISTER_WINDOW," DS=");
1254 PICE_sprintf(tempDisplayRegs,"%.4X",CurrentDS);
1255 if(OldDS!=CurrentDS)
1257 SetForegroundColor(COLOR_HILITE);
1259 Print(REGISTER_WINDOW,tempDisplayRegs);
1260 if(OldDS!=CurrentDS)
1266 Print(REGISTER_WINDOW," ES=");
1267 PICE_sprintf(tempDisplayRegs,"%.4X",CurrentES);
1268 if(OldES!=CurrentES)
1270 SetForegroundColor(COLOR_HILITE);
1272 Print(REGISTER_WINDOW,tempDisplayRegs);
1273 if(OldES!=CurrentES)
1279 Print(REGISTER_WINDOW," FS=");
1280 PICE_sprintf(tempDisplayRegs,"%.4X",CurrentFS);
1281 if(OldFS!=CurrentFS)
1283 SetForegroundColor(COLOR_HILITE);
1285 Print(REGISTER_WINDOW,tempDisplayRegs);
1286 if(OldFS!=CurrentFS)
1292 Print(REGISTER_WINDOW," GS=");
1293 PICE_sprintf(tempDisplayRegs,"%.4X",CurrentGS);
1294 if(OldGS!=CurrentGS)
1298 Print(REGISTER_WINDOW,tempDisplayRegs);
1299 if(OldGS!=CurrentGS)
1305 Print(REGISTER_WINDOW," SS=");
1306 PICE_sprintf(tempDisplayRegs,"%.4X",CurrentSS);
1307 if(OldSS!=CurrentSS)
1309 SetForegroundColor(COLOR_HILITE);
1311 Print(REGISTER_WINDOW,tempDisplayRegs);
1312 if(OldSS!=CurrentSS)
1320 //*************************************************************************
1323 //*************************************************************************
1324 void SaveOldRegs(void)
1349 //*************************************************************************
1352 //*************************************************************************
1353 UCHAR GetKeyStatus(void)
1356 ucRet = inb_p((PUCHAR)(I8042_PHYSICAL_BASE + I8042_STATUS_REGISTER_OFFSET));
1360 //*************************************************************************
1363 //*************************************************************************
1364 UCHAR GetKeyData(void)
1367 ucRet = inb_p((PUCHAR)(I8042_PHYSICAL_BASE + I8042_DATA_REGISTER_OFFSET));
1371 //*************************************************************************
1374 //*************************************************************************
1375 UCHAR KeyboardGetKeyPolled(void)
1379 static BOOLEAN bExtended = FALSE;
1381 while(ucKey=0,(ucStatus=GetKeyStatus())&OUTPUT_BUFFER_FULL)
1384 ucKey = GetKeyData();
1386 if(ucStatus&MOUSE_OUTPUT_BUFFER_FULL)
1389 DPRINT((1,"GetKeyPolled(): key = %x bExtended=%s\n",ucKey,bExtended?"TRUE":"FALSE"));
1391 if(SCANCODE_EXTENDED == ucKey)
1393 DPRINT((1,"extended switched ON\n"));
1399 if(!(ucKey&0x80)) // keypress
1403 case SCANCODE_L_CTRL:
1404 case SCANCODE_R_CTRL:
1408 case SCANCODE_L_SHIFT:
1409 case SCANCODE_R_SHIFT:
1413 case SCANCODE_L_ALT:
1414 case SCANCODE_R_ALT:
1419 DPRINT((0,"GetKeyPolled(): control = %u shift = %u alt = %u\n",bControl,bShift,bAlt));
1427 case SCANCODE_L_CTRL:
1428 case SCANCODE_R_CTRL:
1432 case SCANCODE_L_SHIFT:
1433 case SCANCODE_R_SHIFT:
1437 case SCANCODE_L_ALT:
1438 case SCANCODE_R_ALT:
1451 //*************************************************************************
1452 // KeyboardFlushKeyboardQueue()
1454 //*************************************************************************
1455 void KeyboardFlushKeyboardQueue(void)
1458 KeStallExecutionProcessor(10);
1459 while(GetKeyStatus()&OUTPUT_BUFFER_FULL)
1463 KeStallExecutionProcessor(10);
1467 //*************************************************************************
1470 //*************************************************************************
1471 BOOLEAN CheckLoadAbort(void)
1478 SaveGraphicsState();
1480 FlushKeyboardQueue();
1488 PICE_sprintf(tempUtil,"\n LOAD WILL CONTINUE IN %u SEC (HIT 'C' TO CONTINUE OR ANY OTHER KEY TO ABORT)\n",5-i/1000);
1489 Clear(REGISTER_WINDOW);
1490 Print(REGISTER_WINDOW,tempUtil);
1494 ucKey = GetKeyPolled();
1498 if((ucKey&0x7f)!=46)
1500 RestoreGraphicsState();
1507 KeStallExecutionProcessor(1000);
1510 Clear(REGISTER_WINDOW);
1514 FlushKeyboardQueue();
1516 RestoreGraphicsState();
1526 //*************************************************************************
1529 //*************************************************************************
1530 void IntelStackWalk(ULONG pc,ULONG ebp,ULONG esp)
1532 PULONG pFrame, pPrevFrame;
1535 DPRINT((0,"IntelStackWalk(): pc = %X ebp = %X esp = %X\n",pc,ebp,esp));
1537 pFrame = pPrevFrame = (PULONG)ebp;
1539 PutStatusText("EIP FRAME NAME\n");
1542 DPRINT((0,"IntelStackWalk(): pFrame = %X pPrevFrame = %X pc =%X\n",(ULONG)pFrame,(ULONG)pPrevFrame,pc));
1543 if ( ( (ULONG)pFrame & 3 ) ||
1544 ( (pFrame <= pPrevFrame) ) )
1546 DPRINT((0,"IntelStackWalk(): pFrame is either unaligned or not less than previous\n"));
1547 if( !IsRangeValid((ULONG)pFrame, sizeof(PVOID)*2) )
1549 DPRINT((0,"IntelStackWalk(): pFrame not valid pointer!\n"));
1554 if((pSymbolName = FindFunctionByAddress(pc,NULL,NULL)) )
1555 PICE_sprintf(tempUtil,"%08X %08X %s\n",pc, (ULONG)pFrame,pSymbolName);
1557 PICE_sprintf(tempUtil,"%08X %08X\n",pc, (ULONG)pFrame);
1558 Print(OUTPUT_WINDOW,tempUtil);
1559 if(WaitForKey()==FALSE)break;
1563 pPrevFrame = pFrame;
1565 pFrame = (PULONG)pFrame[0]; // proceed to next higher frame on stack
1569 //*************************************************************************
1570 // FindPteForLinearAddress()
1572 //*************************************************************************
1573 PULONG FindPteForLinearAddress(ULONG address)
1577 BOOLEAN bResult = FALSE;
1578 PEPROCESS my_current = IoGetCurrentProcess();
1582 address &= (~(_PAGE_SIZE-1));
1586 pPGD = ADDR_TO_PDE(address);
1587 if(pPGD && ((*pPGD)&_PAGE_PRESENT))
1590 if(!((*pPGD)&_PAGE_4M))
1592 pPTE = ADDR_TO_PTE(address);
1612 //*************************************************************************
1615 //*************************************************************************
1616 void InvalidateLB(void)
1619 __asm__ __volatile__
1622 mov %%cr3,%%ecx\n\t \
1629 //*************************************************************************
1632 //*************************************************************************
1633 ULONG ReadPhysMem(ULONG Address,ULONG ulSize)
1635 ULONG Page = ((ULONG)TwoPagesForPhysMem+_PAGE_SIZE)&~(_PAGE_SIZE-1);
1641 DPRINT((0,"ReadPhysMem(%.8X,%u)\n",Address,ulSize));
1642 DPRINT((0,"ReadPhysMem(): Page = %.8X\n",Page));
1643 pPTE = (PULONG)FindPteForLinearAddress(Page);
1644 DPRINT((0,"ReadPhysMem(): pPTE = %.8X\n",pPTE));
1648 DPRINT((0,"ReadPhysMem(): oldPTE = %.8X\n",oldPTE));
1649 temp = (Address & ~(_PAGE_SIZE-1));
1650 DPRINT((0,"ReadPhysMem(): page-aligned Address = %.8X\n",temp));
1652 DPRINT((0,"ReadPhysMem(): new PTE = %.8X\n",*pPTE));
1656 case sizeof(UCHAR): // BYTE
1657 temp = *(PUCHAR)(Page + (Address & (_PAGE_SIZE-1)));
1660 case sizeof(USHORT): // WORD
1661 temp = *(PUSHORT)(Page + (Address & (_PAGE_SIZE-1)));
1662 temp = (USHORT)temp;
1664 case sizeof(ULONG): // DWORD
1665 temp = *(PULONG)(Page + (Address & (_PAGE_SIZE-1)));
1676 //*************************************************************************
1679 //*************************************************************************
1680 void WritePhysMem(ULONG Address,ULONG Datum,ULONG ulSize)
1682 ULONG Page = ((ULONG)TwoPagesForPhysMem+_PAGE_SIZE)&~(_PAGE_SIZE-1);
1687 pPTE = (PULONG)FindPteForLinearAddress(Page);
1691 temp = (Address & ~(_PAGE_SIZE-1));
1692 *pPTE = temp | 0x3; // present and writable
1696 case sizeof(UCHAR): // BYTE
1697 *(PUCHAR)(Page + (Address & (_PAGE_SIZE-1))) = (UCHAR)Datum;
1699 case sizeof(USHORT): // WORD
1700 *(PUSHORT)(Page + (Address & (_PAGE_SIZE-1))) = (USHORT)Datum;
1702 case sizeof(ULONG): // DWORD
1703 *(PULONG)(Page + (Address & (_PAGE_SIZE-1))) = Datum;
1711 /////////////////////////////////////////////////////////////////////////////
1712 unsigned long simple_strtoul(const char *cp,char **endp,unsigned int base)
1714 unsigned long result = 0,value;
1721 if ((*cp == 'x') && PICE_isxdigit(cp[1])) {
1727 while (PICE_isxdigit(*cp) && (value = PICE_isdigit(*cp) ? *cp-'0' : (PICE_islower(*cp)
1728 ? PICE_toupper(*cp) : *cp)-'A'+10) < base) {
1729 result = result*base + value;
1737 long simple_strtol(const char *cp,char **endp,unsigned int base)
1740 return -simple_strtoul(cp+1,endp,base);
1741 return simple_strtoul(cp,endp,base);
1744 /* we use this so that we can do without the ctype library */
1745 #define is_digit(c) ((c) >= '0' && (c) <= '9')
1747 static int skip_atoi(const char **s)
1751 while (is_digit(**s))
1752 i = i*10 + *((*s)++) - '0';
1756 size_t PICE_strnlen(const char * s, size_t count)
1760 for (sc = s; count-- && IsAddressValid((ULONG)sc) && *sc != '\0'; ++sc)
1766 #define NUM_ZEROPAD 1 /* pad with zero */
1767 #define NUM_SIGN 2 /* unsigned/signed long */
1768 #define NUM_PLUS 4 /* show plus */
1769 #define NUM_SPACE 8 /* space if plus */
1770 #define NUM_LEFT 16 /* left justified */
1771 #define NUM_SPECIAL 32 /* 0x */
1772 #define NUM_LARGE 64 /* use 'ABCDEF' instead of 'abcdef' */
1774 #define do_div(n,base) ({ \
1776 __res = ((unsigned long) n) % (unsigned) base; \
1777 n = ((unsigned long) n) / (unsigned) base; \
1780 static char * PICE_number(char * str, long num, int base, int size, int precision
1783 char c,sign,tmp[66];
1784 const char *digits="0123456789abcdefghijklmnopqrstuvwxyz";
1787 if (type & NUM_LARGE)
1788 digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1789 if (type & NUM_LEFT)
1790 type &= ~NUM_ZEROPAD;
1791 if (base < 2 || base > 36)
1793 c = (type & NUM_ZEROPAD) ? '0' : ' ';
1795 if (type & NUM_SIGN) {
1800 } else if (type & NUM_PLUS) {
1803 } else if (type & NUM_SPACE) {
1808 if (type & NUM_SPECIAL) {
1817 else while (num != 0)
1818 tmp[i++] = digits[do_div(num,base)];
1822 if (!(type&(NUM_ZEROPAD+NUM_LEFT)))
1827 if (type & NUM_SPECIAL) {
1830 else if (base==16) {
1832 *str++ = digits[33];
1835 if (!(type & NUM_LEFT))
1838 while (i < precision--)
1847 /* Forward decl. needed for IP address printing stuff... */
1848 int PICE_sprintf(char * buf, const char *fmt, ...);
1850 int PICE_vsprintf(char *buf, const char *fmt, va_list args)
1859 int flags; /* flags to PICE_number() */
1861 int field_width; /* width of output field */
1862 int precision; /* min. # of digits for integers; max
1863 PICE_number of chars for from string */
1864 int qualifier; /* 'h', 'l', or 'L' for integer fields */
1866 for (str=buf ; *fmt ; ++fmt) {
1875 ++fmt; /* this also skips first '%' */
1877 case '-': flags |= NUM_LEFT; goto repeat;
1878 case '+': flags |= NUM_PLUS; goto repeat;
1879 case ' ': flags |= NUM_SPACE; goto repeat;
1880 case '#': flags |= NUM_SPECIAL; goto repeat;
1881 case '0': flags |= NUM_ZEROPAD; goto repeat;
1884 /* get field width */
1887 field_width = skip_atoi(&fmt);
1888 else if (*fmt == '*') {
1890 /* it's the next argument */
1891 field_width = va_arg(args, int);
1892 if (field_width < 0) {
1893 field_width = -field_width;
1898 /* get the precision */
1903 precision = skip_atoi(&fmt);
1904 else if (*fmt == '*') {
1906 /* it's the next argument */
1907 precision = va_arg(args, int);
1913 /* get the conversion qualifier */
1915 if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
1925 if (!(flags & NUM_LEFT))
1926 while (--field_width > 0)
1928 *str++ = (unsigned char) va_arg(args, int);
1929 while (--field_width > 0)
1934 s = va_arg(args, char *);
1938 len = PICE_strnlen(s, precision);
1940 if (!(flags & NUM_LEFT))
1941 while (len < field_width--)
1943 for (i = 0; i < len; ++i)
1945 while (len < field_width--)
1950 if (qualifier == 'h') {
1951 /* print ascii string */
1952 s = va_arg(args, char *);
1956 len = PICE_strlen (s);
1957 if ((unsigned int)len > (unsigned int)precision)
1960 if (!(flags & NUM_LEFT))
1961 while (len < field_width--)
1963 for (i = 0; i < len; ++i)
1965 while (len < field_width--)
1968 /* print unicode string */
1969 sw = va_arg(args, wchar_t *);
1974 if ((unsigned int)len > (unsigned int)precision)
1977 if (!(flags & NUM_LEFT))
1978 while (len < field_width--)
1980 for (i = 0; i < len; ++i)
1981 *str++ = (unsigned char)(*sw++);
1982 while (len < field_width--)
1988 if (field_width == -1) {
1989 field_width = 2*sizeof(void *);
1990 flags |= NUM_ZEROPAD;
1992 str = PICE_number(str,
1993 (unsigned long) va_arg(args, void *), 16,
1994 field_width, precision, flags);
1999 if (qualifier == 'l') {
2000 long * ip = va_arg(args, long *);
2003 int * ip = va_arg(args, int *);
2012 /* integer PICE_number formats - set up the flags and "break" */
2037 if (qualifier == 'l')
2038 num = va_arg(args, unsigned long);
2039 else if (qualifier == 'h') {
2040 num = (unsigned short) va_arg(args, int);
2041 if (flags & NUM_SIGN)
2043 } else if (flags & NUM_SIGN)
2044 num = va_arg(args, int);
2046 num = va_arg(args, unsigned int);
2047 str = PICE_number(str, num, base, field_width, precision, flags);
2053 int PICE_sprintf(char * buf, const char *fmt, ...)
2058 va_start(args, fmt);
2059 i = PICE_vsprintf(buf,fmt,args);
2064 //*************************************************************************
2067 // Convert Scancode to ASCII
2068 //*************************************************************************
2069 UCHAR AsciiFromScan(UCHAR s)
2078 table = GetKeyboardLayout()->shifted;
2082 table = GetKeyboardLayout()->alted;
2086 table = GetKeyboardLayout()->normal;
2092 for(i=0;table[i].s != 0;i++)
2102 DPRINT((0,"AsciiFromScan(): no translation for key\n"));
2108 //*************************************************************************
2111 // Convert Scancode to ASCII
2112 //*************************************************************************
2113 UCHAR AsciiToScan(UCHAR s)
2122 table = GetKeyboardLayout()->shifted;
2126 table = GetKeyboardLayout()->alted;
2130 table = GetKeyboardLayout()->normal;
2135 for(i=0;table[i].s != 0;i++)
2145 DPRINT((0,"AsciiToScan(): no translation for ASCII code\n"));
2150 //************************************************************************
2153 //************************************************************************
2154 void outportb(PUCHAR port,UCHAR data)
2156 WRITE_PORT_UCHAR((PUCHAR)port, data);
2159 void outb_p(UCHAR data, PUCHAR port)
2161 WRITE_PORT_UCHAR((PUCHAR)port, data);
2164 VOID outl(ULONG data, PULONG port)
2166 WRITE_PORT_ULONG(port, data);
2170 //************************************************************************
2173 //************************************************************************
2174 UCHAR inportb(PUCHAR port)
2176 return READ_PORT_UCHAR((PUCHAR)port);
2179 UCHAR inb_p(PUCHAR port)
2181 return READ_PORT_UCHAR((PUCHAR)port);
2184 ULONG inl(PULONG port)
2186 return READ_PORT_ULONG(port);
2189 //*************************************************************************
2190 // EnablePassThrough()
2192 // enable MDA passthrough on AGP chipset
2193 //*************************************************************************
2194 void EnablePassThrough(void)
2201 oldCF8 = inl((PULONG)0xcf8);
2202 outl(0x80000050,(PULONG)0xcf8);
2203 outl(inl((PULONG)0xcfc)|0x00000020,(PULONG)0xcfc);
2204 outl(oldCF8,(PULONG)0xcf8);
2206 restore_flags(flags);
2209 //***********************************************************************************
2210 // Pice_malloc - allocate memory from paged or non-paged pool
2211 //***********************************************************************************
2212 void * PICE_malloc( size_t numBytes, BOOLEAN fromPaged )
2214 void* res = ExAllocatePool( (fromPaged)?PagedPool:NonPagedPool, numBytes );
2219 //***********************************************************************************
2220 // PICE_free - free memory allocated by PICE_malloc
2221 //***********************************************************************************
2222 void PICE_free( void* p )
2228 long PICE_read(HANDLE hFile, LPVOID lpBuffer, long lBytes)
2230 DWORD NumberOfBytesRead;
2231 IO_STATUS_BLOCK iosb;
2235 if (!NT_SUCCESS(NtReadFile(
2237 NULL, NULL, NULL, &iosb,
2246 NumberOfBytesRead = iosb.Information;
2247 return NumberOfBytesRead;
2250 HANDLE PICE_open (LPCWSTR lpPathName, int iReadWrite)
2252 DWORD dwAccessMask = 0;
2253 DWORD dwShareMode = 0;
2254 UNICODE_STRING TmpFileName;
2255 OBJECT_ATTRIBUTES ObjectAttributes;
2260 DPRINT((0,"PICE_open: %S\n", lpPathName));
2262 if ( (iReadWrite & OF_READWRITE ) == OF_READWRITE )
2263 dwAccessMask = GENERIC_READ | GENERIC_WRITE;
2264 else if ( (iReadWrite & OF_READ ) == OF_READ )
2265 dwAccessMask = GENERIC_READ;
2266 else if ( (iReadWrite & OF_WRITE ) == OF_WRITE )
2267 dwAccessMask = GENERIC_WRITE;
2269 if ((iReadWrite & OF_SHARE_COMPAT) == OF_SHARE_COMPAT )
2270 dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE;
2271 else if ((iReadWrite & OF_SHARE_DENY_NONE) == OF_SHARE_DENY_NONE)
2272 dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE;
2273 else if ((iReadWrite & OF_SHARE_DENY_READ) == OF_SHARE_DENY_READ)
2274 dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_DELETE;
2275 else if ((iReadWrite & OF_SHARE_DENY_WRITE) == OF_SHARE_DENY_WRITE )
2276 dwShareMode = FILE_SHARE_READ | FILE_SHARE_DELETE;
2277 else if ((iReadWrite & OF_SHARE_EXCLUSIVE) == OF_SHARE_EXCLUSIVE)
2280 RtlInitUnicodeString (&TmpFileName, lpPathName);
2281 InitializeObjectAttributes(&ObjectAttributes,
2287 status = NtOpenFile( &hfile,
2290 NULL, dwShareMode, FILE_NO_INTERMEDIATE_BUFFERING);
2291 //BUG BUG check status!!!
2292 if( !NT_SUCCESS( status ) ){
2293 DPRINT((0,"PICE_open: NtOpenFile error: %x\n", status));
2299 int PICE_close (HANDLE hFile)
2301 if (NT_SUCCESS( ZwClose((HANDLE)hFile)))
2305 DPRINT((0,"ZwClose failed:\n"));
2309 size_t PICE_len( HANDLE hFile )
2311 FILE_STANDARD_INFORMATION fs;
2312 IO_STATUS_BLOCK iosb;
2315 status = ZwQueryInformationFile( hFile, &iosb, &fs, sizeof fs, FileStandardInformation );
2316 if( !NT_SUCCESS( status ) ){
2317 DPRINT((0,"PICE_len: ZwQueryInformationFile error: %x\n", status));
2320 //ASSERT(fs.EndOfFile.u.HighPart == 0);
2321 return (size_t)fs.EndOfFile.u.LowPart;
2326 * A raw converter for now. It assumes lpMultiByteStr is
2327 * NEVER multi-byte (that is each input character is
2328 * 8-bit ASCII) and is ALWAYS NULL terminated.
2329 * FIXME-FIXME-FIXME-FIXME
2334 PICE_MultiByteToWideChar (
2337 LPCSTR lpMultiByteStr,
2339 LPWSTR lpWideCharStr,
2343 int InStringLength = 0;
2344 BOOL InIsNullTerminated = TRUE;
2350 * Check the parameters.
2352 if ( /* --- CODE PAGE --- */
2353 ( (CP_ACP != CodePage)
2354 && (CP_MACCP != CodePage)
2355 && (CP_OEMCP != CodePage))
2357 /*|| (dwFlags ^ ( MB_PRECOMPOSED
2359 | MB_ERR_INVALID_CHARS
2363 /* --- INPUT BUFFER --- */
2364 || (NULL == lpMultiByteStr)
2367 DPRINT((0,"ERROR_INVALID_PARAMETER\n"));
2371 * Compute the input buffer length.
2373 if (-1 == cchMultiByte)
2375 InStringLength = PICE_strlen(lpMultiByteStr);
2379 InIsNullTerminated = FALSE;
2380 InStringLength = cchMultiByte;
2383 * Does caller query for output
2386 if (0 == cchWideChar)
2388 DPRINT((0,"ERROR_SUCCESS\n"));
2389 return InStringLength;
2392 * Is space provided for the translated
2395 if (cchWideChar < InStringLength)
2397 DPRINT((0,"ERROR_INSUFFICIENT_BUFFER: cchWideChar: %d, InStringLength: %d\n", cchWideChar, InStringLength));
2401 * Raw 8- to 16-bit conversion.
2403 for ( cchConverted = 0,
2404 r = (PCHAR) lpMultiByteStr,
2405 w = (PWCHAR) lpWideCharStr;
2407 ((*r) && (cchConverted < cchWideChar));
2416 * Is the input string NULL terminated?
2418 if (TRUE == InIsNullTerminated)
2424 * Return how many characters we
2425 * wrote in the output buffer.
2427 return cchConverted;