]>
Commit | Line | Data |
---|---|---|
1 | //----------------------------------------------------------------------------- | |
2 | // Copyright (C) 2013 m h swende <martin at swende.se> | |
3 | // | |
4 | // This code is licensed to you under the terms of the GNU GPL, version 2 or, | |
5 | // at your option, any later version. See the LICENSE.txt file for the text of | |
6 | // the license. | |
7 | //----------------------------------------------------------------------------- | |
8 | // Some lua scripting glue to proxmark core. | |
9 | //----------------------------------------------------------------------------- | |
10 | ||
11 | #include <lua.h> | |
12 | #include <lualib.h> | |
13 | #include <lauxlib.h> | |
14 | #include "proxmark3.h" | |
15 | #include "usb_cmd.h" | |
16 | #include "cmdmain.h" | |
17 | #include "scripting.h" | |
18 | #include "util.h" | |
19 | #include "nonce2key/nonce2key.h" | |
20 | #include "../common/iso15693tools.h" | |
21 | #include "iso14443crc.h" | |
22 | #include "../common/crc16.h" | |
23 | #include "../common/crc64.h" | |
24 | #include "../common/sha1.h" | |
25 | #include "aes.h" | |
26 | #include "cmdcrc.h" | |
27 | /** | |
28 | * The following params expected: | |
29 | * UsbCommand c | |
30 | *@brief l_SendCommand | |
31 | * @param L | |
32 | * @return | |
33 | */ | |
34 | static int l_SendCommand(lua_State *L){ | |
35 | ||
36 | /* | |
37 | * | |
38 | The SendCommand (native) expects the following structure: | |
39 | ||
40 | typedef struct { | |
41 | uint64_t cmd; //8 bytes | |
42 | uint64_t arg[3]; // 8*3 bytes = 24 bytes | |
43 | union { | |
44 | uint8_t asBytes[USB_CMD_DATA_SIZE]; // 1 byte * 512 = 512 bytes (OR) | |
45 | uint32_t asDwords[USB_CMD_DATA_SIZE/4]; // 4 byte * 128 = 512 bytes | |
46 | } d; | |
47 | } PACKED UsbCommand; | |
48 | ||
49 | ==> A 544 byte buffer will do. | |
50 | **/ | |
51 | //Pop cmd | |
52 | size_t size; | |
53 | const char *data = luaL_checklstring(L, 1, &size); | |
54 | if(size != sizeof(UsbCommand)) | |
55 | { | |
56 | printf("Got data size %d, expected %d" , (int) size,(int) sizeof(UsbCommand)); | |
57 | lua_pushstring(L,"Wrong data size"); | |
58 | return 1; | |
59 | } | |
60 | ||
61 | // UsbCommand c = (*data); | |
62 | SendCommand((UsbCommand* )data); | |
63 | return 0; // no return values | |
64 | } | |
65 | /** | |
66 | * @brief The following params expected: | |
67 | * uint32_t cmd | |
68 | * size_t ms_timeout | |
69 | * @param L | |
70 | * @return | |
71 | */ | |
72 | static int l_WaitForResponseTimeout(lua_State *L){ | |
73 | ||
74 | uint32_t cmd = 0; | |
75 | size_t ms_timeout = -1; | |
76 | ||
77 | //Check number of arguments | |
78 | int n = lua_gettop(L); | |
79 | if(n == 0) | |
80 | { | |
81 | //signal error by returning Nil, errorstring | |
82 | lua_pushnil(L); | |
83 | lua_pushstring(L,"You need to supply at least command to wait for"); | |
84 | return 2; // two return values | |
85 | } | |
86 | if(n >= 1) | |
87 | { | |
88 | //pop cmd | |
89 | cmd = luaL_checkunsigned(L,1); | |
90 | } | |
91 | if(n >= 2) | |
92 | { | |
93 | //Did the user send a timeout ? | |
94 | //Check if the current top of stack is an integer | |
95 | ms_timeout = luaL_checkunsigned(L,2); | |
96 | //printf("Timeout set to %dms\n" , (int) ms_timeout); | |
97 | } | |
98 | ||
99 | UsbCommand response; | |
100 | ||
101 | if(WaitForResponseTimeout(cmd, &response, ms_timeout)) | |
102 | { | |
103 | //Push it as a string | |
104 | lua_pushlstring(L,(const char *)&response,sizeof(UsbCommand)); | |
105 | ||
106 | return 1;// return 1 to signal one return value | |
107 | }else{ | |
108 | //Push a Nil instead | |
109 | lua_pushnil(L); | |
110 | return 1;// one return value | |
111 | } | |
112 | } | |
113 | ||
114 | static int returnToLuaWithError(lua_State *L, const char* fmt, ...) | |
115 | { | |
116 | char buffer[200]; | |
117 | va_list args; | |
118 | va_start(args,fmt); | |
119 | vsnprintf(buffer, sizeof(buffer), fmt,args); | |
120 | va_end(args); | |
121 | ||
122 | lua_pushnil(L); | |
123 | lua_pushstring(L,buffer); | |
124 | return 2; | |
125 | } | |
126 | ||
127 | static int l_nonce2key(lua_State *L){ | |
128 | ||
129 | size_t size; | |
130 | const char *p_uid = luaL_checklstring(L, 1, &size); | |
131 | if(size != 4) return returnToLuaWithError(L,"Wrong size of uid, got %d bytes, expected 4", (int) size); | |
132 | ||
133 | const char *p_nt = luaL_checklstring(L, 2, &size); | |
134 | if(size != 4) return returnToLuaWithError(L,"Wrong size of nt, got %d bytes, expected 4", (int) size); | |
135 | ||
136 | const char *p_nr = luaL_checklstring(L, 3, &size); | |
137 | if(size != 4) return returnToLuaWithError(L,"Wrong size of nr, got %d bytes, expected 4", (int) size); | |
138 | ||
139 | const char *p_par_info = luaL_checklstring(L, 4, &size); | |
140 | if(size != 8) return returnToLuaWithError(L,"Wrong size of par_info, got %d bytes, expected 8", (int) size); | |
141 | ||
142 | const char *p_pks_info = luaL_checklstring(L, 5, &size); | |
143 | if(size != 8) return returnToLuaWithError(L,"Wrong size of ks_info, got %d bytes, expected 8", (int) size); | |
144 | ||
145 | ||
146 | uint32_t uid = bytes_to_num(( uint8_t *)p_uid,4); | |
147 | uint32_t nt = bytes_to_num(( uint8_t *)p_nt,4); | |
148 | ||
149 | uint32_t nr = bytes_to_num(( uint8_t*)p_nr,4); | |
150 | uint64_t par_info = bytes_to_num(( uint8_t *)p_par_info,8); | |
151 | uint64_t ks_info = bytes_to_num(( uint8_t *)p_pks_info,8); | |
152 | ||
153 | uint64_t key = 0; | |
154 | ||
155 | int retval = nonce2key(uid,nt, nr, par_info,ks_info, &key); | |
156 | ||
157 | //Push the retval on the stack | |
158 | lua_pushinteger(L,retval); | |
159 | ||
160 | //Push the key onto the stack | |
161 | uint8_t dest_key[8]; | |
162 | num_to_bytes(key,sizeof(dest_key),dest_key); | |
163 | ||
164 | //printf("Pushing to lua stack: %012"llx"\n",key); | |
165 | lua_pushlstring(L,(const char *) dest_key,sizeof(dest_key)); | |
166 | ||
167 | return 2; //Two return values | |
168 | } | |
169 | //static int l_PrintAndLog(lua_State *L){ return CmdHF14AMfDump(luaL_checkstring(L, 1));} | |
170 | static int l_clearCommandBuffer(lua_State *L){ | |
171 | clearCommandBuffer(); | |
172 | return 0; | |
173 | } | |
174 | /** | |
175 | * @brief l_foobar is a dummy function to test lua-integration with | |
176 | * @param L | |
177 | * @return | |
178 | */ | |
179 | static int l_foobar(lua_State *L) | |
180 | { | |
181 | //Check number of arguments | |
182 | int n = lua_gettop(L); | |
183 | printf("foobar called with %d arguments" , n); | |
184 | lua_settop(L, 0); | |
185 | printf("Arguments discarded, stack now contains %d elements", lua_gettop(L)); | |
186 | ||
187 | // todo: this is not used, where was it intended for? | |
188 | // UsbCommand response = {CMD_MIFARE_READBL, {1337, 1338, 1339}}; | |
189 | ||
190 | printf("Now returning a uint64_t as a string"); | |
191 | uint64_t x = 0xDEADBEEF; | |
192 | uint8_t destination[8]; | |
193 | num_to_bytes(x,sizeof(x),destination); | |
194 | lua_pushlstring(L,(const char *)&x,sizeof(x)); | |
195 | lua_pushlstring(L,(const char *)destination,sizeof(destination)); | |
196 | ||
197 | return 2; | |
198 | } | |
199 | ||
200 | ||
201 | /** | |
202 | * @brief Utility to check if a key has been pressed by the user. This method does not block. | |
203 | * @param L | |
204 | * @return boolean, true if kbhit, false otherwise. | |
205 | */ | |
206 | static int l_ukbhit(lua_State *L) | |
207 | { | |
208 | lua_pushboolean(L,ukbhit() ? true : false); | |
209 | return 1; | |
210 | } | |
211 | /** | |
212 | * @brief Calls the command line parser to deal with the command. This enables | |
213 | * lua-scripts to do stuff like "core.console('hf mf mifare')" | |
214 | * @param L | |
215 | * @return | |
216 | */ | |
217 | static int l_CmdConsole(lua_State *L) | |
218 | { | |
219 | CommandReceived((char *)luaL_checkstring(L, 1)); | |
220 | return 0; | |
221 | } | |
222 | ||
223 | static int l_iso15693_crc(lua_State *L) | |
224 | { | |
225 | // uint16_t Iso15693Crc(uint8_t *v, int n); | |
226 | size_t size; | |
227 | const char *v = luaL_checklstring(L, 1, &size); | |
228 | uint16_t retval = Iso15693Crc((uint8_t *) v, size); | |
229 | lua_pushinteger(L, (int) retval); | |
230 | return 1; | |
231 | } | |
232 | ||
233 | static int l_iso14443b_crc(lua_State *L) | |
234 | { | |
235 | /* void ComputeCrc14443(int CrcType, | |
236 | const unsigned char *Data, int Length, | |
237 | unsigned char *TransmitFirst, | |
238 | unsigned char *TransmitSecond) | |
239 | */ | |
240 | unsigned char buf[USB_CMD_DATA_SIZE]; | |
241 | size_t len = 0; | |
242 | const char *data = luaL_checklstring(L, 1, &len); | |
243 | if (USB_CMD_DATA_SIZE < len) | |
244 | len = USB_CMD_DATA_SIZE-2; | |
245 | ||
246 | for (int i = 0; i < len; i += 2) { | |
247 | sscanf(&data[i], "%02x", (unsigned int *)&buf[i / 2]); | |
248 | } | |
249 | ComputeCrc14443(CRC_14443_B, buf, len, &buf[len], &buf[len+1]); | |
250 | ||
251 | lua_pushlstring(L, (const char *)&buf, len+2); | |
252 | return 1; | |
253 | } | |
254 | /* | |
255 | Simple AES 128 cbc hook up to OpenSSL. | |
256 | params: key, input | |
257 | */ | |
258 | static int l_aes128decrypt_cbc(lua_State *L) | |
259 | { | |
260 | //Check number of arguments | |
261 | int i; | |
262 | size_t size; | |
263 | const char *p_key = luaL_checklstring(L, 1, &size); | |
264 | if(size != 32) return returnToLuaWithError(L,"Wrong size of key, got %d bytes, expected 32", (int) size); | |
265 | ||
266 | const char *p_encTxt = luaL_checklstring(L, 2, &size); | |
267 | ||
268 | unsigned char indata[16] = {0x00}; | |
269 | unsigned char outdata[16] = {0x00}; | |
270 | unsigned char aes_key[16] = {0x00}; | |
271 | unsigned char iv[16] = {0x00}; | |
272 | ||
273 | // convert key to bytearray and convert input to bytearray | |
274 | for (i = 0; i < 32; i += 2) { | |
275 | sscanf(&p_encTxt[i], "%02x", (unsigned int *)&indata[i / 2]); | |
276 | sscanf(&p_key[i], "%02x", (unsigned int *)&aes_key[i / 2]); | |
277 | } | |
278 | ||
279 | aes_context ctx; | |
280 | aes_init(&ctx); | |
281 | aes_setkey_dec(&ctx, aes_key, 128); | |
282 | aes_crypt_cbc(&ctx,AES_DECRYPT,sizeof(indata), iv, indata,outdata ); | |
283 | //Push decrypted array as a string | |
284 | lua_pushlstring(L,(const char *)&outdata, sizeof(outdata)); | |
285 | return 1;// return 1 to signal one return value | |
286 | } | |
287 | static int l_aes128decrypt_ecb(lua_State *L) | |
288 | { | |
289 | //Check number of arguments | |
290 | int i; | |
291 | size_t size; | |
292 | const char *p_key = luaL_checklstring(L, 1, &size); | |
293 | if(size != 32) return returnToLuaWithError(L,"Wrong size of key, got %d bytes, expected 32", (int) size); | |
294 | ||
295 | const char *p_encTxt = luaL_checklstring(L, 2, &size); | |
296 | ||
297 | unsigned char indata[16] = {0x00}; | |
298 | unsigned char outdata[16] = {0x00}; | |
299 | unsigned char aes_key[16] = {0x00}; | |
300 | ||
301 | // convert key to bytearray and convert input to bytearray | |
302 | for (i = 0; i < 32; i += 2) { | |
303 | sscanf(&p_encTxt[i], "%02x", (unsigned int *)&indata[i / 2]); | |
304 | sscanf(&p_key[i], "%02x", (unsigned int *)&aes_key[i / 2]); | |
305 | } | |
306 | aes_context ctx; | |
307 | aes_init(&ctx); | |
308 | aes_setkey_dec(&ctx, aes_key, 128); | |
309 | aes_crypt_ecb(&ctx, AES_DECRYPT, indata, outdata ); | |
310 | ||
311 | //Push decrypted array as a string | |
312 | lua_pushlstring(L,(const char *)&outdata, sizeof(outdata)); | |
313 | return 1;// return 1 to signal one return value | |
314 | } | |
315 | ||
316 | static int l_aes128encrypt_cbc(lua_State *L) | |
317 | { | |
318 | //Check number of arguments | |
319 | int i; | |
320 | size_t size; | |
321 | const char *p_key = luaL_checklstring(L, 1, &size); | |
322 | if(size != 32) return returnToLuaWithError(L,"Wrong size of key, got %d bytes, expected 32", (int) size); | |
323 | ||
324 | const char *p_txt = luaL_checklstring(L, 2, &size); | |
325 | ||
326 | unsigned char indata[16] = {0x00}; | |
327 | unsigned char outdata[16] = {0x00}; | |
328 | unsigned char aes_key[16] = {0x00}; | |
329 | unsigned char iv[16] = {0x00}; | |
330 | ||
331 | for (i = 0; i < 32; i += 2) { | |
332 | sscanf(&p_txt[i], "%02x", (unsigned int *)&indata[i / 2]); | |
333 | sscanf(&p_key[i], "%02x", (unsigned int *)&aes_key[i / 2]); | |
334 | } | |
335 | ||
336 | aes_context ctx; | |
337 | aes_init(&ctx); | |
338 | aes_setkey_enc(&ctx, aes_key, 128); | |
339 | aes_crypt_cbc(&ctx, AES_ENCRYPT, sizeof(indata), iv, indata, outdata ); | |
340 | //Push encrypted array as a string | |
341 | lua_pushlstring(L,(const char *)&outdata, sizeof(outdata)); | |
342 | return 1;// return 1 to signal one return value | |
343 | } | |
344 | ||
345 | static int l_aes128encrypt_ecb(lua_State *L) | |
346 | { | |
347 | //Check number of arguments | |
348 | int i; | |
349 | size_t size; | |
350 | const char *p_key = luaL_checklstring(L, 1, &size); | |
351 | if(size != 32) return returnToLuaWithError(L,"Wrong size of key, got %d bytes, expected 32", (int) size); | |
352 | ||
353 | const char *p_txt = luaL_checklstring(L, 2, &size); | |
354 | ||
355 | unsigned char indata[16] = {0x00}; | |
356 | unsigned char outdata[16] = {0x00}; | |
357 | unsigned char aes_key[16] = {0x00}; | |
358 | ||
359 | for (i = 0; i < 32; i += 2) { | |
360 | sscanf(&p_txt[i], "%02x", (unsigned int *)&indata[i / 2]); | |
361 | sscanf(&p_key[i], "%02x", (unsigned int *)&aes_key[i / 2]); | |
362 | } | |
363 | aes_context ctx; | |
364 | aes_init(&ctx); | |
365 | aes_setkey_enc(&ctx, aes_key, 128); | |
366 | aes_crypt_ecb(&ctx, AES_ENCRYPT, indata, outdata ); | |
367 | //Push encrypted array as a string | |
368 | lua_pushlstring(L,(const char *)&outdata, sizeof(outdata)); | |
369 | return 1;// return 1 to signal one return value | |
370 | } | |
371 | ||
372 | static int l_crc16(lua_State *L) | |
373 | { | |
374 | size_t size; | |
375 | const char *p_str = luaL_checklstring(L, 1, &size); | |
376 | ||
377 | uint16_t retval = crc16_ccitt( (uint8_t*) p_str, size); | |
378 | lua_pushinteger(L, (int) retval); | |
379 | return 1; | |
380 | } | |
381 | ||
382 | static int l_crc64(lua_State *L) | |
383 | { | |
384 | size_t size; | |
385 | uint64_t crc = 0; | |
386 | unsigned char outdata[8] = {0x00}; | |
387 | ||
388 | const char *p_str = luaL_checklstring(L, 1, &size); | |
389 | ||
390 | crc64( (uint8_t*) p_str, size, &crc); | |
391 | ||
392 | outdata[0] = (uint8_t)(crc >> 56) & 0xff; | |
393 | outdata[1] = (uint8_t)(crc >> 48) & 0xff; | |
394 | outdata[2] = (uint8_t)(crc >> 40) & 0xff; | |
395 | outdata[3] = (uint8_t)(crc >> 32) & 0xff; | |
396 | outdata[4] = (uint8_t)(crc >> 24) & 0xff; | |
397 | outdata[5] = (uint8_t)(crc >> 16) & 0xff; | |
398 | outdata[6] = (uint8_t)(crc >> 8) & 0xff; | |
399 | outdata[7] = crc & 0xff; | |
400 | lua_pushlstring(L,(const char *)&outdata, sizeof(outdata)); | |
401 | return 1; | |
402 | } | |
403 | ||
404 | static int l_sha1(lua_State *L) | |
405 | { | |
406 | size_t size; | |
407 | const char *p_str = luaL_checklstring(L, 1, &size); | |
408 | unsigned char outdata[20] = {0x00}; | |
409 | sha1( (uint8_t*) p_str, size, outdata); | |
410 | lua_pushlstring(L,(const char *)&outdata, sizeof(outdata)); | |
411 | return 1; | |
412 | } | |
413 | ||
414 | static int l_reveng_models(lua_State *L){ | |
415 | ||
416 | char *models[80]; | |
417 | int count = 0; | |
418 | int in_width = luaL_checkinteger(L, 1); | |
419 | ||
420 | if( in_width > 89 ) return returnToLuaWithError(L,"Width cannot exceed 89, got %d", in_width); | |
421 | ||
422 | uint8_t width[80]; | |
423 | width[0] = (uint8_t)in_width; | |
424 | int ans = GetModels(models, &count, width); | |
425 | if (!ans) return 0; | |
426 | ||
427 | lua_newtable(L); | |
428 | ||
429 | for (int i = 0; i < count; i++){ | |
430 | lua_pushstring(L, (const char*)models[i]); | |
431 | lua_rawseti(L,-2,i+1); | |
432 | free(models[i]); | |
433 | } | |
434 | ||
435 | return 1; | |
436 | } | |
437 | ||
438 | //Called with 4 parameters. | |
439 | // inModel ,string containing the crc model name: 'CRC-8' | |
440 | // inHexStr ,string containing the hex representation of the data that will be used for CRC calculations. | |
441 | // reverse ,int 0/1 (bool) if 1, calculate the reverse CRC | |
442 | // endian ,char, 'B','b','L','l','t','r' describing if Big-Endian or Little-Endian should be used in different combinations. | |
443 | // | |
444 | // outputs: string with hex representation of the CRC result | |
445 | static int l_reveng_RunModel(lua_State *L){ | |
446 | //-c || -v | |
447 | //inModel = valid model name string - CRC-8 | |
448 | //inHexStr = input hex string to calculate crc on | |
449 | //reverse = reverse calc option if true | |
450 | //endian = {0 = calc default endian input and output, b = big endian input and output, B = big endian output, r = right justified | |
451 | // l = little endian input and output, L = little endian output only, t = left justified} | |
452 | //result = calculated crc hex string | |
453 | char result[50]; | |
454 | ||
455 | const char *inModel = luaL_checkstring(L, 1); | |
456 | const char *inHexStr = luaL_checkstring(L, 2); | |
457 | bool reverse = lua_toboolean(L, 3); | |
458 | const char endian = luaL_checkstring(L, 4)[0]; | |
459 | ||
460 | //PrintAndLog("mod: %s, hex: %s, rev %d", inModel, inHexStr, reverse); | |
461 | //int RunModel(char *inModel, char *inHexStr, bool reverse, char endian, char *result) | |
462 | int ans = RunModel( (char *)inModel, (char *)inHexStr, reverse, endian, result); | |
463 | if (!ans) | |
464 | return returnToLuaWithError(L,"Reveng failed"); | |
465 | ||
466 | lua_pushstring(L, (const char*)result); | |
467 | return 1; | |
468 | } | |
469 | ||
470 | /** | |
471 | * @brief Sets the lua path to include "./lualibs/?.lua", in order for a script to be | |
472 | * able to do "require('foobar')" if foobar.lua is within lualibs folder. | |
473 | * Taken from http://stackoverflow.com/questions/4125971/setting-the-global-lua-path-variable-from-c-c | |
474 | * @param L | |
475 | * @param path | |
476 | * @return | |
477 | */ | |
478 | int setLuaPath( lua_State* L, const char* path ) | |
479 | { | |
480 | lua_getglobal( L, "package" ); | |
481 | lua_getfield( L, -1, "path" ); // get field "path" from table at top of stack (-1) | |
482 | const char* cur_path = lua_tostring( L, -1 ); // grab path string from top of stack | |
483 | int requiredLength = strlen(cur_path)+ strlen(path)+10; //A few bytes too many, whatever we can afford it | |
484 | char * buf = malloc(requiredLength); | |
485 | snprintf(buf, requiredLength, "%s;%s", cur_path, path); | |
486 | lua_pop( L, 1 ); // get rid of the string on the stack we just pushed on line 5 | |
487 | lua_pushstring( L, buf ); // push the new one | |
488 | lua_setfield( L, -2, "path" ); // set the field "path" in table at -2 with value at top of stack | |
489 | lua_pop( L, 1 ); // get rid of package table from top of stack | |
490 | free(buf); | |
491 | return 0; // all done! | |
492 | } | |
493 | ||
494 | ||
495 | int set_pm3_libraries(lua_State *L) | |
496 | { | |
497 | ||
498 | static const luaL_Reg libs[] = { | |
499 | {"SendCommand", l_SendCommand}, | |
500 | {"WaitForResponseTimeout", l_WaitForResponseTimeout}, | |
501 | {"nonce2key", l_nonce2key}, | |
502 | //{"PrintAndLog", l_PrintAndLog}, | |
503 | {"foobar", l_foobar}, | |
504 | {"ukbhit", l_ukbhit}, | |
505 | {"clearCommandBuffer", l_clearCommandBuffer}, | |
506 | {"console", l_CmdConsole}, | |
507 | {"iso15693_crc", l_iso15693_crc}, | |
508 | {"iso14443b_crc", l_iso14443b_crc}, | |
509 | {"aes128_decrypt", l_aes128decrypt_cbc}, | |
510 | {"aes128_decrypt_ecb", l_aes128decrypt_ecb}, | |
511 | {"aes128_encrypt", l_aes128encrypt_cbc}, | |
512 | {"aes128_encrypt_ecb", l_aes128encrypt_ecb}, | |
513 | {"crc16", l_crc16}, | |
514 | {"crc64", l_crc64}, | |
515 | {"sha1", l_sha1}, | |
516 | {"reveng_models", l_reveng_models}, | |
517 | {"reveng_runmodel", l_reveng_RunModel}, | |
518 | {NULL, NULL} | |
519 | }; | |
520 | ||
521 | lua_pushglobaltable(L); | |
522 | // Core library is in this table. Contains ' | |
523 | //this is 'pm3' table | |
524 | lua_newtable(L); | |
525 | ||
526 | //Put the function into the hash table. | |
527 | for (int i = 0; libs[i].name; i++) { | |
528 | lua_pushcfunction(L, libs[i].func); | |
529 | lua_setfield(L, -2, libs[i].name);//set the name, pop stack | |
530 | } | |
531 | //Name of 'core' | |
532 | lua_setfield(L, -2, "core"); | |
533 | ||
534 | //-- remove the global environment table from the stack | |
535 | lua_pop(L, 1); | |
536 | ||
537 | //-- Last but not least, add to the LUA_PATH (package.path in lua) | |
538 | // so we can load libraries from the ./lualib/ - directory | |
539 | setLuaPath(L,"./lualibs/?.lua"); | |
540 | ||
541 | return 1; | |
542 | } |