Como modificar este código VC++...

[gayo1100]

 Hola, buscando en la web encontré un código para cambiar el numero de serie del disco duro, he intentado modificarlo para que cambie el numero de serie en  dos discos duros a la vez, por ej. C: y D:, pero me da fallos, la verdad no soy experto en VC++ mis conocimientos son mas bién no amplios, lo he intentado pero nada de nada, agradecería a algún experto me hechara una mano.
Mi idea es que una vez que se ejecute el archivo (archivo.cpp), que se vuelva a ejecutar otra vez el mismo codigo en otro archivo (archivo2.cpp)-->este seria para D: , pero cuando he probrado a insertar en el proyecto (archivo2.cpp) da fallos...
El proyecto consta de : archivo.cpp, cabecera.h, cabecera.cpp
Muchas gracias de antemano.

los archivos (*.h) no estan, pero el principal (archivo.cpp) es  :
///////////////////////////////////////////////////////////////

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>


void ShowErrorString(char *str)
{
  printf(str);
}

void ChangeSerialNumber(DWORD Drive, const DWORD newSerial)
{
  DiskSector disk;

  const max_pbsi = 1;

  struct partial_boot_sector_info
  {
    LPSTR Fs;
    DWORD FsOffs;
    DWORD SerialOffs;
  };

  partial_boot_sector_info pbsi[max_pbsi] =
  {
 
   {"NTFS",0x48}
 
  };

  TCHAR szDrive[12];

  char Sector[512];

  DWORD i;

  sprintf(szDrive, "%c:\", Drive & 0xFF);

  if (!disk.Open(szDrive))
  {
    ShowErrorString("No se puede abrir el disco !");
    return;
  }

  // read sector
  if (!disk.ReadSector(0, Sector))
  {
    ShowErrorString("No se puede leer el sector!");
    return;
  }

  // try to search for a valid boot sector
  for (i=0;i<max_pbsi;i++)
  {
    if (strncmp(pbsi.Fs, Sector+pbsi.FsOffs, strlen(pbsi.Fs)) == 0)
    {
      // we found a valid signature
      break;
    }
  }

  // patch serial number
  *(PDWORD)(Sector+pbsi.SerialOffs) = newSerial;

  // write boot sector
  if (!disk.WriteSector(0, Sector))
  {
    ShowErrorString("No se puede escribir el sector!");
    return;
  }

  ShowErrorString("Cambio realizado !");
                 
}

int main(int argc, char **argv)

{
  if (argc < 3)
  {
    ChangeSerialNumber('C', 0x12345678);  // aqui cambia en C:
    return 0;                                        
  }                                                                            
  DWORD n;

  char *temp;
  n = strtol((const char *)argv[2], &temp, 16);
  ChangeSerialNumber(toupper(argv[1][0]), n);
  return 0;
}
//////////////////////////////////////////////////////////

[m0skit0]

Hola gayo1100, te aconsejo que uses las etiquetas de código cuando pongas código.

Este programa ya puede cambiar el número de serie de cualquier unidad que le especifiques. Sólo tienes que pasárselo por argumentos. Te explico un poco:

Fíjate que la función main() está hecha para recibir argumentos de entrada: argc te da el número de argumentos y argv[] los argumentos como cadenas de caracteres.

Código: C

1. if (argc < 3)
2. {
3.     ChangeSerialNumber('C', 0x12345678); // aqui cambia en C:
4.     return 0;
5. }
6.  

Sólo si los argumentos son menores que 3 se ejecuta el cambio que comentas: el número de serie del lector C: a 0x12345678.

Fíjate ahora en este parte del código:

Código: Text

1. n = strtol((const char *)argv[2], &temp, 16);
2. ChangeSerialNumber(toupper(argv[1][0]), n);
3.  

En la primera sentencia, el segundo argumento pasado al programa (char *argv[2]) se convierte a DWORD n, es decir, una cadena de caracteres a un número de 32 bits (como 0x12345678).

Ahora si nos fijamos en la segunda sentencia y vemos qué valores se pasan a ChangeSerialNumber(DWORD Drive, const DWORD newSerial), vemos que argv[1][0] corresponde a un tipo char (como 'C' en la anterior llamada), así que el primer argumento es la letra del lector. El segundo parámetro es n, que corresponde al segundo argumento argv[2] (como 0x12345678 en la otra llamada).

Así que, si tu programa fuera changeserial.exe, podrías poner changeserial d 0x03456765 para cambiar el serial del lector D: a 03456765.

Espero haberme explicado, cualquier duda me comentas. ¡Salud!

[gayo1100]

 Muchas gracias mosquito por tu respuesta, pero creo que me he explicado mal, he estado haciendo lo que me dices y estupendo..., he realizado algunos cambios y funciona, pero con demasiado codigo, me explico...
No se como simplificar o realizar un bucle de n veces que yo quiera, minimizar tener que poner dos veces lo mismo.
Esta

Código: C++

1.  
2. void ChangeSerialNumber(DWORD Drive, const DWORD newSerial)
3.  
4.  

Vale, lo que hago es poner dos veces el contenido de este

Código: C++

1.  
2. void ChangeSerialNumber2(DWORD Drive, const DWORD newSerial) //aqui cambio a ChangeSerialNumber2
3.  
4.  

Ahora te adjunto el resultado final para FAT16 probado en USB PENDRIVE

Código: C++

1.  
2. ///////////////////////////////////////////////////////////////////////////
3.  
4. #include <windows.h>
5. #include <stdio.h>
6. #include <stdlib.h>
7.  
8.  
9. void ShowErrorString(char *str)
10. {
11. printf(str);
12. }
13.  
14. void ChangeSerialNumber(DWORD Drive, const DWORD newSerial)
15. {
16. DiskSector disk;
17.  
18. const max_pbsi = 1;
19.  
20. struct partial_boot_sector_info
21. {
22. LPSTR Fs;
23. DWORD FsOffs;
24. DWORD SerialOffs;
25. };
26.  
27. partial_boot_sector_info pbsi[max_pbsi] =
28. {
29.  
30.     {"FAT",0x27}  //Direccion para numero de serie en FAT16 PENDRIVE USB
31.  
32. };
33.  
34. TCHAR szDrive[12];
35.  
36. char Sector[512];
37.  
38. DWORD i;
39.  
40. sprintf(szDrive, "%c:\", Drive & 0xFF);
41.  
42. if (!disk.Open(szDrive))
43. {
44. ShowErrorString("No se puede abrir el disco !");
45. return;
46. }
47.  
48. // read sector
49. if (!disk.ReadSector(0, Sector))
50. {
51. ShowErrorString("No se puede leer el sector!");
52. return;
53. }
54.  
55. // try to search for a valid boot sector
56. for (i=0;i<max_pbsi;i++)
57. {
58. if (strncmp(pbsi.Fs, Sector+pbsi.FsOffs, strlen(pbsi.Fs)) == 0)
59. {
60. // we found a valid signature
61. break;
62. }
63. }
64.  
65. // patch serial number
66. *(PDWORD)(Sector+pbsi.SerialOffs) = newSerial;
67.  
68. // write boot sector
69. if (!disk.WriteSector(0, Sector))
70. {
71. ShowErrorString("No se puede escribir el sector!");
72. return;
73. }
74.  
75. ShowErrorString("Cambio realizado !");
76.  
77. }
78.  
79.  
80. }
81. //////////////////////////////////////////////////////////////////////////////////////
82. AQUI CONTINUA EL MISMO CODIGO PERO CAMBIANDO ChangeSerialNumber a ChangeSerialNumber2
83. puesto que vamos a cambiar en direccion diferente para el cambio de etiqueta
84. //////////////////////////////////////////////////////////////////////////////////////
85.  
86. void ChangeSerialNumber2(DWORD Drive, const DWORD newSerial)
87. {
88. DiskSector disk;
89.  
90. const max_pbsi = 1;
91.  
92. struct partial_boot_sector_info
93. {
94. LPSTR Fs;
95. DWORD FsOffs;
96. DWORD SerialOffs;
97. };
98.  
99. partial_boot_sector_info pbsi[max_pbsi] =
100. {
101.  
102.     {"FAT",0x2B}  //0X2B Direccion para etiqueta disco
103.  
104. };
105.  
106. TCHAR szDrive[12];
107.  
108. char Sector[512];
109.  
110. DWORD i;
111.  
112. sprintf(szDrive, "%c:\", Drive & 0xFF);
113.  
114. if (!disk.Open(szDrive))
115. {
116. ShowErrorString("No se puede abrir el disco !");
117. return;
118. }
119.  
120. // read sector
121. if (!disk.ReadSector(0, Sector))
122. {
123. ShowErrorString("No se puede leer el sector!");
124. return;
125. }
126.  
127. // try to search for a valid boot sector
128. for (i=0;i<max_pbsi;i++)
129. {
130. if (strncmp(pbsi.Fs, Sector+pbsi.FsOffs, strlen(pbsi.Fs)) == 0)
131. {
132. // we found a valid signature
133. break;
134. }
135. }
136.  
137. // patch serial number
138. *(PDWORD)(Sector+pbsi.SerialOffs) = newSerial;
139.  
140. // write boot sector
141. if (!disk.WriteSector(0, Sector))
142. {
143. ShowErrorString("No se puede escribir el sector!");
144. return;
145. }
146.  
147. ShowErrorString("Cambio realizado !");
148.  
149. }
150.  
151.  
152. int main(int argc, char **argv)
153. {
154.   if (argc < 3)
155.    
156.     {
157.     ChangeSerialNumber('G', 0x12345678); // aqui cambia numero de serie G: usb pendrive FAT16
158.     ChangeSerialNumber2('G', 0xJONATHAN); // aqui cambia la etiqueta volumen G: usb pendrive FAT16
159.  
160.     return 0;
161.     }
162. }
163.  
164.  

Es exactamente lo mimo pero cambia la direccion donde se va a modificar, cambia aqui:

Código: C++

1.  
2. En el primer void ChangeSerialNumber(DWORD Drive, const DWORD newSerial)
3. partial_boot_sector_info pbsi[max_pbsi] =
4. {
5.  {"FAT",0x27}  //0X27 Direccion para numero de serie
6. };
7. Y en el segundo void ChangeSerialNumber2(DWORD Drive, const DWORD newSerial)
8. partial_boot_sector_info pbsi[max_pbsi] =
9. {
10.  {"FAT",0x2B}  //0X2B Direccion para etiqueta disco
11. };
12.  
13.  

En resumen quiero simplificar esto y no se como hacer para hacerlo en un paso...te agradecería me orientaras.
Muchas gracias otra vez y un saludo.

[m0skit0]

Por lo que he entendido, ChangeSerialNumber2() cambia la etiqueta y no el número de serie. Si es así, ponle un nombre más adecuado, tipo CambiarEtiqueta().

Lo que no termino de entender es 0xJONATHAN . Esto te tiene que dar un error como una casa...

minimizar tener que poner dos veces lo mismo.

Entonces haz una sola función general que llame a dos funciones diferentes dependiendo de si es el número de serie o etiqueta tipo:

Código: C

1. void ModificarDisco(DWORD Lector, UBYTE Modificar, DWORD NuevoValor)
2.  

donde Modificar lleva un numero que indica qué modificar o y NuevoValor es un puntero al nuevo valor de modificación. Dentro de esta función compruebas Modificar y luego aplicas lo conveniente. Lo bueno de esto es que ModificarDisco() puede agrupar el código que tengan comunes ambas funciones, dejando ChangeSerialNumber() y ChangeSerialNumber2() con código distinto. Siempre aconsejo que las funciones sean lo más específicas y cortas posible.

Espero haberme explicado, saludos.

[gayo1100]

Si efectivamente el valor de cambio etiqueta esta mal, me he equivocado, tiene que ir en formato hexadecimal..., el valor que asigno es JOSE como etiqueta de volumen que en hex = 0x4A4F5345, no entiendo muy bíen lo que dices de funcion general que llame a las dos funciones, no se como plantearla, demasiado para mi...gracias de todas formas por tu ayuda
y si puedes hacer algo te lo agradecería.
El codigo modificado resultante seria:

Código: C++

1.  
2. ///////////////////////////////////////////////////////////////////////////
3.  
4. #include <windows.h>
5. #include <stdio.h>
6. #include <stdlib.h>
7.  
8.  
9. void ShowErrorString(char *str)
10. {
11. printf(str);
12. }
13.  
14. void ModificarDisco(DWORD Drive, const DWORD newSerial)
15. {
16. DiskSector disk;
17.  
18. const max_pbsi = 1;
19.  
20. struct partial_boot_sector_info
21. {
22. LPSTR Fs;
23. DWORD FsOffs;
24. DWORD SerialOffs;
25. };
26.  
27. partial_boot_sector_info pbsi[max_pbsi] =
28. {
29.  
30.     {"FAT",0x27}  //Direccion hex. para numero de serie en FAT16 PENDRIVE USB
31.  
32. };
33.  
34. TCHAR szDrive[12];
35.  
36. char Sector[512];
37.  
38. DWORD i;
39.  
40. sprintf(szDrive, "%c:\", Drive & 0xFF);
41.  
42. if (!disk.Open(szDrive))
43. {
44. ShowErrorString("No se puede abrir el disco !");
45. return;
46. }
47.  
48. // read sector
49. if (!disk.ReadSector(0, Sector))
50. {
51. ShowErrorString("No se puede leer el sector!");
52. return;
53. }
54.  
55. // try to search for a valid boot sector
56. for (i=0;i<max_pbsi;i++)
57. {
58. if (strncmp(pbsi.Fs, Sector+pbsi.FsOffs, strlen(pbsi.Fs)) == 0)
59. {
60. // we found a valid signature
61. break;
62. }
63. }
64.  
65. // patch serial number
66. *(PDWORD)(Sector+pbsi.SerialOffs) = newSerial;
67.  
68. // write boot sector
69. if (!disk.WriteSector(0, Sector))
70. {
71. ShowErrorString("No se puede escribir el sector!");
72. return;
73. }
74.  
75. ShowErrorString("Cambio realizado !");
76.  
77. }
78.  
79.  
80. }
81. //////////////////////////////////////////////////////////////////////////////////////
82. AQUI CONTINUA EL MISMO CODIGO PERO CAMBIANDO a CambiarEtiqueta
83. //////////////////////////////////////////////////////////////////////////////////////
84.  
85. void CambiarEtiqueta(DWORD Drive, const DWORD newSerial)
86. {
87. DiskSector disk;
88.  
89. const max_pbsi = 1;
90.  
91. struct partial_boot_sector_info
92. {
93. LPSTR Fs;
94. DWORD FsOffs;
95. DWORD SerialOffs;
96. };
97.  
98. partial_boot_sector_info pbsi[max_pbsi] =
99. {
100.  
101.     {"FAT",0x2B}  //0X2B Direccion hex. para etiqueta disco
102.  
103. };
104.  
105. TCHAR szDrive[12];
106.  
107. char Sector[512];
108.  
109. DWORD i;
110.  
111. sprintf(szDrive, "%c:\", Drive & 0xFF);
112.  
113. if (!disk.Open(szDrive))
114. {
115. ShowErrorString("No se puede abrir el disco !");
116. return;
117. }
118.  
119. // read sector
120. if (!disk.ReadSector(0, Sector))
121. {
122. ShowErrorString("No se puede leer el sector!");
123. return;
124. }
125.  
126. // try to search for a valid boot sector
127. for (i=0;i<max_pbsi;i++)
128. {
129. if (strncmp(pbsi.Fs, Sector+pbsi.FsOffs, strlen(pbsi.Fs)) == 0)
130. {
131. // we found a valid signature
132. break;
133. }
134. }
135.  
136. // patch serial number
137. *(PDWORD)(Sector+pbsi.SerialOffs) = newSerial;
138.  
139. // write boot sector
140. if (!disk.WriteSector(0, Sector))
141. {
142. ShowErrorString("No se puede escribir el sector!");
143. return;
144. }
145.  
146. ShowErrorString("Cambio realizado !");
147.  
148. }
149.  
150.  
151. int main(int argc, char **argv)
152. {
153.   if (argc < 3)
154.    
155.     {
156.     ModificarDisco('G', 0x12345678); // -->valor =12345678 aqui cambia numero de serie G: usb pendrive FAT16
157.     CambiarEtiqueta('G', 0x4A4F5345); // -->valor=JOSE -->aqui cambia la etiqueta volumen G: usb pendrive FAT16
158.  
159.     return 0;
160.     }
161. }
162.  
163.