Changeset 845

Timestamp:

08/09/08 10:44:55 (3 years ago)

Author:

mwhitworth

Message:

Add constants and extra functions to console and registry.

Location:

Whitix/trunk/user/sdk

Files:

• include/registry.h (modified) (2 diffs)
• python/console/main.c (modified) (1 diff)
• python/registry/main.c (modified) (2 diffs)
• registry/registry.c (modified) (7 diffs)

Whitix/trunk/user/sdk/include/registry.h

@@ -3 +3 @@
 
 #define REG_NAME_LENGTH         1024
+
+#define REG_KEY_TYPE_STR        0
+#define REG_KEY_TYPE_INT        1
 
 struct Registry
@@ -15 +18 @@
 };
 
+struct RegKeySetIter
+{
+        struct RegKeySet* keySet;
+        int bufSize;
+        char* buf;
+        int next, size, index;
+};
+
+int RegRegistryOpen(char* name, struct Registry* registry);
+int RegKeySetOpen(struct Registry* registry, char* name, unsigned long accessRights, struct RegKeySet* keySet);
+int RegKeyReadString(struct RegKeySet* keySet, char* name, char** data, unsigned long* length);
+int RegKeyReadInt(struct RegKeySet* keySet, char* name, int* ret);
+int RegKeySetReadKey(struct RegKeySet* keySet, char* name, int* type, char* data, unsigned long* length);
+
 #endif

Whitix/trunk/user/sdk/python/console/main.c

@@ -262 +262 @@
                 return;
 
+        PyModule_AddIntConstant(m, "ColorBlue", CONS_COLOR_BLUE);
+
         ReadLineInit();
 }

Whitix/trunk/user/sdk/python/registry/main.c

@@ -79 +79 @@
         
         if (RegKeySetOpen(&self->registry, name, accessRights, &keySet))
-        {
-                Py_INCREF(Py_None);
-                return Py_None;
-        }
+                return PyErr_Format(PyExc_KeyError, "Could not find key %s", name);
                         
         regKeySet=PyObject_GC_New(WRegKeySet, &wRegKeySet_Type);
@@ -197 +194 @@
                                         (PyObject *)&wRegKeySetIter_Type) < 0)
                 return;
+                
+        PyModule_AddIntConstant(m, "EntryKey", 0);
+        PyModule_AddIntConstant(m, "EntryKeySet", 1);
 }

Whitix/trunk/user/sdk/registry/registry.c

@@ -9 +9 @@
 #define REG_PACKET_OPEN_KEYSET          1
 #define REG_PACKET_READ_KEY                     2
+#define REG_PACKET_ENUM_KEYSET          3
+#define REG_PACKET_GET_ENT_TYPE         4
+
+/* Used for locating an entry. */
+struct RegReadKeyPacket
+{
+        int type;
+        int length;
+        unsigned long handleId;
+        char name[REG_NAME_LENGTH];
+};
 
 int RegRegistryOpen(char* name, struct Registry* registry)
@@ -26 +37 @@
         
         NetSocketConnect(sockFd, &addr, sizeof(struct SocketAddr));
-                
+
         registry->sockFd=sockFd;
-                
+        
         return 0;
 }
@@ -68 +79 @@
         NetSocketReceive(registry->sockFd, &handleId, 4, 0);
         
+        if (handleId == -1)
+                return -1;
+        
         keySet->handleId=handleId;
         keySet->registry=registry;
@@ -79 +93 @@
 }
 
+int RegKeyReadInt(struct RegKeySet* keySet, char* name, int* ret)
+{
+        int type, length=sizeof(int);
+        
+        if (RegKeySetReadKey(keySet, name, &type, ret, &length) < 0)
+                return -1;
+                
+        if (type != REG_KEY_TYPE_INT)
+                return -1;
+                
+        return 0;
+}
+
+int RegKeyReadString(struct RegKeySet* keySet, char* name, char** data, unsigned long* length)
+{
+        int type;
+        unsigned long rLength=2048;
+        
+        /* TODO: Check return to see if buf needs to be expanded? */
+        
+        if (!*data)
+                *data=malloc(2048);
+                
+        if (length)
+                rLength=*length;
+        
+        if (RegKeySetReadKey(keySet, name, &type, *data, &rLength) < 0)
+                return -1;
+                
+        if (type != REG_KEY_TYPE_STR)
+                return -1;
+        
+        if (length)     
+                *length=rLength;
+        
+        return 0;
+}
+
 /* TODO: Expand format to multiple keys. */
 
@@ -88 +140 @@
         if (!keySet || !name)
                 return -1;
-                
-        struct RegReadKeyPacket
-        {
-                int type;
-                int length;
-                unsigned long handleId;
-                char name[REG_NAME_LENGTH];
-        };
         
         struct RegReadKeyReply
@@ -120 +164 @@
                 
         NetSocketReceive(sockFd, &reply, sizeof(struct RegReadKeyReply), 0);
-        
-//      printf("error = %d, length = %u, type = %d\n", reply.error, reply.length, reply.type);
         
         if (data)
@@ -134 +176 @@
         *length=NetSocketReceive(sockFd, data, *length, 0);
         
-        return 0;
-}
+        if (type)
+                *type=reply.type;
+        
+        return 0;
+}
+
+int RegKeySetIterInit(struct RegKeySet* keySet, struct RegKeySetIter* iter)
+{
+        iter->keySet=keySet;
+        iter->bufSize=4096;
+        iter->buf=(char*)malloc(4096);
+        iter->next=0;
+        iter->index=0;
+        iter->size=0;
+                
+        return 0;
+}
+
+char* RegKeySetIterNext(struct RegKeySetIter* iter)
+{
+        struct RegEnumSetPacket
+        {
+                int type;
+                int length;
+                unsigned long handleId;
+                unsigned long index;
+                unsigned long size;
+        };
+        
+        char* ret;
+        int bytes;
+        int sockFd;
+        
+        sockFd=iter->keySet->registry->sockFd;
+        
+        if (!iter)
+                return NULL;
+                
+        if (iter->size <= iter->next)
+                iter->size=iter->next=0;
+                
+        if (iter->size == 0)
+        {
+                /* Get the next batch of directory entries. */
+                struct RegEnumSetPacket packet;
+                packet.type=REG_PACKET_ENUM_KEYSET;
+                packet.length=sizeof(struct RegEnumSetPacket);
+                packet.handleId=iter->keySet->handleId;
+                packet.index=iter->index;
+                packet.size=iter->bufSize;
+                
+                bytes=NetSocketSend(sockFd, &packet, packet.length, 0);
+                
+                if (bytes <= 0)
+                        return NULL;
+                
+                bytes=NetSocketReceive(sockFd, iter->buf, iter->bufSize, 0);
+                iter->size=bytes;
+                
+                if (bytes <= 0)
+                        return NULL;
+                
+                printf("Got %d bytes\n", bytes);
+        }
+        
+        ret=iter->buf+iter->next;
+        iter->next+=strlen(ret)+1;
+        iter->index++;
+        
+        return ret;
+}
+
+int RegKeySetIterClose(struct RegKeySetIter* iter)
+{
+        if (!iter)
+                return -1;
+                
+        free(iter->buf);
+        
+        return 0;
+}
+
+int RegEntryGetType(struct RegKeySet* keySet, char* name, int* ret)
+{
+        struct RegReadKeyPacket packet;
+        int sockFd, err;
+        
+        sockFd=keySet->registry->sockFd;
+        
+        packet.type=REG_PACKET_GET_ENT_TYPE;
+        packet.length=sizeof(struct RegReadKeyPacket);
+        packet.handleId=keySet->handleId;
+        strncpy(packet.name, name, REG_NAME_LENGTH);
+        
+        err=NetSocketSend(sockFd, &packet, sizeof(struct RegReadKeyPacket), 0);
+        
+        if (err < 0)
+                return err;
+                
+        NetSocketReceive(sockFd, ret, 4, 0);
+        
+        return 0;
+}