nvidia-settings: fix -Werror=format-security errors

Signed-off-by: Sachin Chitte <schitte@nvidia.com>
(cherry picked from commit 2e80e4fdc20e051090289e4b32d713a7c4f7e14c)

Conflicts:
	src/gtk+-2.x/ctkdisplayconfig-utils.c
	src/gtk+-2.x/ctkdisplayconfig.c

27 files changed, 185 insertions, 185 deletions

diff --git a/src/command-line.c b/src/command-line.c
index 70c001d..6d481d3 100644
--- a/src/command-line.c
+++ b/src/command-line.c
@@ -59,7 +59,7 @@ extern const char *pNV_ID;
 static void print_version(void)
 {
     nv_msg(NULL, "");
-    nv_msg(NULL, pNV_ID);
+    nv_msg(NULL, "%s", pNV_ID);
     nv_msg(TAB, "The NVIDIA X Server Settings tool.");
     nv_msg(NULL, "");
     nv_msg(TAB, "This program is used to configure the "
@@ -128,7 +128,7 @@ static void print_attribute_help(char *attr)
                 if (entry->flags & NV_PARSER_TYPE_VALUE_IS_SWITCH_DISPLAY)
                     nv_msg(NULL, "  - Attribute value is switch display.");
 
-                nv_msg(TAB, entry->desc);
+                nv_msg(TAB, "%s", entry->desc);
                 nv_msg(NULL, "");
             } else {
                 nv_msg(NULL, "%s", entry->name);
@@ -148,8 +148,8 @@ static void print_attribute_help(char *attr)
 
 static void print_help_helper(const char *name, const char *description)
 {
-    nv_msg(TAB, name);
-    nv_msg_preserve_whitespace(BIGTAB, description);
+    nv_msg(TAB, "%s", name);
+    nv_msg_preserve_whitespace(BIGTAB, "%s", description);
     nv_msg(NULL, "");
 }
 
diff --git a/src/glxinfo.c b/src/glxinfo.c
index 2d5252c..364d640 100644
--- a/src/glxinfo.c
+++ b/src/glxinfo.c
@@ -415,21 +415,21 @@ void print_glxinfo(const char *display_name, CtrlHandlesArray *handles_array)
         /* Print results */
         nv_msg(TAB, "direct rendering: %s", NULL_TO_EMPTY(direct_rendering));
         nv_msg(TAB, "GLX extensions:");
-        nv_msg("    ", NULL_TO_EMPTY(glx_extensions));
+        nv_msg("    ", "%s", NULL_TO_EMPTY(glx_extensions));
         nv_msg(" ", "\n");
         nv_msg(TAB, "server glx vendor string: %s",
                NULL_TO_EMPTY(server_vendor));
         nv_msg(TAB, "server glx version string: %s",
                NULL_TO_EMPTY(server_version));
         nv_msg(TAB, "server glx extensions:");
-        nv_msg("    ", NULL_TO_EMPTY(server_extensions));
+        nv_msg("    ", "%s", NULL_TO_EMPTY(server_extensions));
         nv_msg(" ", "\n");
         nv_msg(TAB, "client glx vendor string: %s",
                NULL_TO_EMPTY(client_vendor));
         nv_msg(TAB, "client glx version string: %s",
                NULL_TO_EMPTY(client_version));
         nv_msg(TAB, "client glx extensions:");
-        nv_msg("    ", NULL_TO_EMPTY(client_extensions));
+        nv_msg("    ", "%s", NULL_TO_EMPTY(client_extensions));
         nv_msg(" ", "\n");
         nv_msg(TAB, "OpenGL vendor string: %s",
                NULL_TO_EMPTY(opengl_vendor));
@@ -438,7 +438,7 @@ void print_glxinfo(const char *display_name, CtrlHandlesArray *handles_array)
         nv_msg(TAB, "OpenGL version string: %s",
                NULL_TO_EMPTY(opengl_version));
         nv_msg(TAB, "OpenGL extensions:");
-        nv_msg("    ", NULL_TO_EMPTY(opengl_extensions));
+        nv_msg("    ", "%s", NULL_TO_EMPTY(opengl_extensions));
 #ifdef GLX_VERSION_1_3        
         if ( fbconfig_attribs != NULL ) {
             nv_msg(" ", "\n");
diff --git a/src/gtk+-2.x/ctk3dvisionpro.c b/src/gtk+-2.x/ctk3dvisionpro.c
index 312be78..453a8b9 100644
--- a/src/gtk+-2.x/ctk3dvisionpro.c
+++ b/src/gtk+-2.x/ctk3dvisionpro.c
@@ -1778,7 +1778,7 @@ GtkTextBuffer *ctk_3d_vision_pro_create_help(GtkTextTagTable *table)
                          "with the hub.");
 
     ctk_help_heading(b, &i, "Add glasses");
-    ctk_help_para(b, &i, __add_glasses_tooltip);
+    ctk_help_para(b, &i, "%s", __add_glasses_tooltip);
     ctk_help_para(b, &i, "This action is used to set up new 3D Vision Pro Glasses. "
                          "On clicking this button the hub enters into pairing mode. "
                          "Follow the instructions on Add Glasses dialog box. "
@@ -1787,7 +1787,7 @@ GtkTextBuffer *ctk_3d_vision_pro_create_help(GtkTextTagTable *table)
                          " glasses or 'Cancel' if do not wish to store them.");
 
     ctk_help_heading(b, &i, "Refresh Glasses' Information");
-    ctk_help_para(b, &i, __refresh_tooltip);
+    ctk_help_para(b, &i, "%s", __refresh_tooltip);
     ctk_help_para(b, &i, "Refresh glasses information is typically required when- \n"
                          "o Glasses move in and out of the range.\n"
                          "o Get the updated battery level of all the glasses.");
@@ -1799,18 +1799,18 @@ GtkTextBuffer *ctk_3d_vision_pro_create_help(GtkTextTagTable *table)
                          "for a few seconds.");
 
     ctk_help_heading(b, &i, "Rename glasses");
-    ctk_help_para(b, &i, __rename_tooltip);
+    ctk_help_para(b, &i, "%s", __rename_tooltip);
     ctk_help_para(b, &i, "Select the glasses from the list of paired glasses "
                          "that you want to rename and provide an unique new name.");
 
     ctk_help_heading(b, &i, "Remove glasses");
-    ctk_help_para(b, &i, __remove_glasses_tooltip);
+    ctk_help_para(b, &i, "%s", __remove_glasses_tooltip);
     ctk_help_para(b, &i, "Select the glasses from the list of paired glasses "
                          "that you want to remove. On removal glasses get "
                          "unpaired and will not sync to the hub.");
 
     ctk_help_heading(b, &i, "Glasses Information");
-    ctk_help_para(b, &i, __goggle_info_tooltip);
+    ctk_help_para(b, &i, "%s", __goggle_info_tooltip);
 
     ctk_help_heading(b, &i, "Glasses Name");
     ctk_help_para(b, &i, "Each pair of glasses has an unique name and the name should "
@@ -1839,7 +1839,7 @@ GtkTextBuffer *ctk_3d_vision_pro_create_help(GtkTextTagTable *table)
                          "\tNo Signal\t\t [0%%]");
 
     ctk_help_heading(b, &i, "Hub Range");
-    ctk_help_para(b, &i, __channel_range_tooltip);
+    ctk_help_para(b, &i, "%s", __channel_range_tooltip);
     ctk_help_para(b, &i, "The hub range is the farthest distance that the "
                          "glasses can synchronize with the 3D Vision Pro Hub. "
                          "You can reduce the hub range to limit the experience "
diff --git a/src/gtk+-2.x/ctkappprofile.c b/src/gtk+-2.x/ctkappprofile.c
index 9e31333..526b0a0 100644
--- a/src/gtk+-2.x/ctkappprofile.c
+++ b/src/gtk+-2.x/ctkappprofile.c
@@ -4068,8 +4068,8 @@ GtkTextBuffer *ctk_app_profile_create_help(CtkAppProfile *ctk_app_profile, GtkTe
     ctk_help_para(b, &i, "This NVIDIA® Linux Graphics Driver supports detection of the following features:");
 
     for (j = 0; j < NUM_RULE_FEATURES; j++) {
-        ctk_help_term(b, &i, rule_feature_label_strings[j]);
-        ctk_help_para(b, &i, rule_feature_help_text[j]);
+        ctk_help_term(b, &i, "%s", rule_feature_label_strings[j]);
+        ctk_help_para(b, &i, "%s", rule_feature_help_text[j]);
     }
 
     ctk_help_heading(b, &i, "Supported Setting Keys");
@@ -4078,8 +4078,8 @@ GtkTextBuffer *ctk_app_profile_create_help(CtkAppProfile *ctk_app_profile, GtkTe
                          "keys. For more information on a given key, please consult the README.");
 
     for (j = 0; j < NUM_PROFILE_SETTINGS; j++) {
-        ctk_help_term(b, &i, profile_setting_keys[j]);
-        ctk_help_para(b, &i, profile_setting_descriptions[j]);
+        ctk_help_term(b, &i, "%s", profile_setting_keys[j]);
+        ctk_help_para(b, &i, "%s", profile_setting_descriptions[j]);
     }
 
     ctk_help_finish(b);
diff --git a/src/gtk+-2.x/ctkclocks.c b/src/gtk+-2.x/ctkclocks.c
index 35d5bdf..47d7158 100644
--- a/src/gtk+-2.x/ctkclocks.c
+++ b/src/gtk+-2.x/ctkclocks.c
@@ -599,7 +599,7 @@ GtkTextBuffer *ctk_clocks_create_help(GtkTextTagTable *table,
                   "void manufacturer warranties.  DO THIS AT YOUR OWN RISK."
                   );
     ctk_help_heading(b, &i, "Enabling Clock Frequencies");
-    ctk_help_para(b, &i, __enable_button_help);
+    ctk_help_para(b, &i, "%s", __enable_button_help);
     ctk_help_para(b, &i,
                   "GPU Overclocking functionality is currently limited to "
                   "GeForce FX and newer non-mobile GPUs."
@@ -614,21 +614,21 @@ GtkTextBuffer *ctk_clocks_create_help(GtkTextTagTable *table,
                   "frequencies used when running 3D applications."
                   );
     ctk_help_heading(b, &i, "Graphics Clock Frequency");
-    ctk_help_para(b, &i, __graphics_clock_help);
+    ctk_help_para(b, &i, "%s", __graphics_clock_help);
     ctk_help_heading(b, &i, "Memory Clock Frequency");
-    ctk_help_para(b, &i, __mem_clock_help);
+    ctk_help_para(b, &i, "%s", __mem_clock_help);
     ctk_help_heading(b, &i, "Applying Custom Clock Frequencies");
-    ctk_help_para(b, &i, __apply_button_help);
+    ctk_help_para(b, &i, "%s", __apply_button_help);
     ctk_help_heading(b, &i, "Auto Detect Optimal 3D Clock Frequencies");
-    ctk_help_para(b, &i, __detect_button_help);
+    ctk_help_para(b, &i, "%s", __detect_button_help);
     ctk_help_heading(b, &i, "Canceling Optimal 3D Clock Frequency Auto-"
                      "detection.");
-    ctk_help_para(b, &i, __cancel_button_help);
+    ctk_help_para(b, &i, "%s", __cancel_button_help);
     ctk_help_para(b, &i,
                   "This button is only available if the Optimal "
                   "clocks are currently being probed.");
     ctk_help_heading(b, &i, "Restoring Hardware Default Frequencies");
-    ctk_help_para(b, &i, __reset_button_help);
+    ctk_help_para(b, &i, "%s", __reset_button_help);
 
     ctk_help_finish(b);
 
@@ -886,10 +886,10 @@ static void auto_detection_state_received(GtkObject *object,
     /* Update the status bar */
 
     if ( ctk_object->probing_optimal ) {
-        ctk_config_statusbar_message(ctk_object->ctk_config,
+        ctk_config_statusbar_message(ctk_object->ctk_config, "%s",
                                      __detect_wait_msg);
     } else {
-        ctk_config_statusbar_message(ctk_object->ctk_config,
+        ctk_config_statusbar_message(ctk_object->ctk_config, "%s",
                                      __canceled_msg);
     }
 
@@ -1379,7 +1379,7 @@ void ctk_clocks_select(GtkWidget *widget)
 
     if ( ret == NvCtrlSuccess &&
          value == NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE_BUSY ) {
-        ctk_config_statusbar_message(ctk_object->ctk_config,
+        ctk_config_statusbar_message(ctk_object->ctk_config, "%s",
                                      __detect_wait_msg);
     }
 }
diff --git a/src/gtk+-2.x/ctkcolorcontrols.c b/src/gtk+-2.x/ctkcolorcontrols.c
index 913e0e7..ba2f3d5 100644
--- a/src/gtk+-2.x/ctkcolorcontrols.c
+++ b/src/gtk+-2.x/ctkcolorcontrols.c
@@ -523,13 +523,13 @@ void add_color_controls_help(CtkColorControls *ctk_color_controls,
     }
 
     ctk_help_heading(b, i, "Color Controls");
-    ctk_help_para(b, i, __color_controls_help);
+    ctk_help_para(b, i, "%s", __color_controls_help);
 
     ctk_help_term(b, i, "Color Space");
-    ctk_help_para(b, i, __color_space_help);
+    ctk_help_para(b, i, "%s", __color_space_help);
 
     ctk_help_term(b, i, "Color Range");
-    ctk_help_para(b, i, __color_range_help);
+    ctk_help_para(b, i, "%s", __color_range_help);
 } /* add_color_controls_help() */
 
 
diff --git a/src/gtk+-2.x/ctkcolorcorrection.c b/src/gtk+-2.x/ctkcolorcorrection.c
index 25b3fe9..6afb93f 100644
--- a/src/gtk+-2.x/ctkcolorcorrection.c
+++ b/src/gtk+-2.x/ctkcolorcorrection.c
@@ -1053,7 +1053,7 @@ GtkTextBuffer *ctk_color_correction_create_help(GtkTextTagTable *table)
     ctk_color_correction_tab_help(b, &i, title, FALSE /* randr */);
     
     ctk_help_heading(b, &i, "Reset Hardware Defaults");
-    ctk_help_para(b, &i, __resest_button_help);
+    ctk_help_para(b, &i, "%s", __resest_button_help);
 
     ctk_help_finish(b);
 
@@ -1068,7 +1068,7 @@ void ctk_color_correction_tab_help(GtkTextBuffer *b, GtkTextIter *i,
     ctk_help_heading(b, i, "Color Correction");
 
     ctk_help_term(b, i, "Active Color Channel");
-    ctk_help_para(b, i, __active_color_help);
+    ctk_help_para(b, i, "%s", __active_color_help);
 
     ctk_help_term(b, i, "Brightness, Contrast and Gamma");
     ctk_help_para(b, i, "The Brightness, Contrast and Gamma sliders "
@@ -1087,7 +1087,7 @@ void ctk_color_correction_tab_help(GtkTextBuffer *b, GtkTextIter *i,
                   "value equally across all channels will make these games "
                   "appear brighter, making them more playable.");
 
-    ctk_help_para(b, i, __color_curve_help);
+    ctk_help_para(b, i, "%s", __color_curve_help);
 
     if (randr) {
         ctk_help_para(b, i, "The %s tab uses the RandR extension to "
@@ -1098,5 +1098,5 @@ void ctk_color_correction_tab_help(GtkTextBuffer *b, GtkTextIter *i,
     }
 
     ctk_help_term(b, i, "Confirm Current Changes");
-    ctk_help_para(b, i, __confirm_button_help);
+    ctk_help_para(b, i, "%s", __confirm_button_help);
 }
diff --git a/src/gtk+-2.x/ctkdisplayconfig-utils.c b/src/gtk+-2.x/ctkdisplayconfig-utils.c
index ee58898..b5a53fa 100644
--- a/src/gtk+-2.x/ctkdisplayconfig-utils.c
+++ b/src/gtk+-2.x/ctkdisplayconfig-utils.c
@@ -1485,7 +1485,7 @@ Bool display_add_modelines_from_server(nvDisplayPtr display, nvGpuPtr gpu,
                                   "device %d '%s'.",
                                    NvCtrlGetTargetId(display->handle),
                                    display->logName);
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         goto fail;
     }
 
@@ -1503,7 +1503,7 @@ Bool display_add_modelines_from_server(nvDisplayPtr display, nvGpuPtr gpu,
                                        NvCtrlGetTargetId(display->handle),
                                        display->logName,
                                        str);
-            nv_error_msg(*err_str);
+            nv_error_msg("%s", *err_str);
             goto fail;
         }
 
@@ -2304,7 +2304,7 @@ static Bool screen_add_metamodes(nvScreenPtr screen, gchar **err_str)
                                    "screen %d (on GPU-%d).",
                                    screen->scrnum,
                                    NvCtrlGetTargetId(screen->gpu->handle));
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         goto fail;
     }
 
@@ -2318,7 +2318,7 @@ static Bool screen_add_metamodes(nvScreenPtr screen, gchar **err_str)
                                    "screen %d (on GPU-%d).",
                                    screen->scrnum,
                                    NvCtrlGetTargetId(screen->gpu->handle));
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         goto fail;
     }
 
@@ -2612,7 +2612,7 @@ static Bool display_add_name_from_server(nvDisplayPtr display,
                                    "device DPY-%d.",
                                    displayNameInfo->nameDescription,
                                    NvCtrlGetTargetId(display->handle));
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         return FALSE;
     }
 
@@ -2651,7 +2651,7 @@ nvDisplayPtr gpu_add_display_from_server(nvGpuPtr gpu,
                                    "display %d (on GPU-%d).",
                                    display_id,
                                    NvCtrlGetTargetId(gpu->handle));
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         goto fail;
     }
 
@@ -2808,7 +2808,7 @@ static Bool gpu_add_displays_from_server(nvGpuPtr gpu, gchar **err_str)
         *err_str = g_strdup_printf("Failed to query list of displays \n"
                                    "connected to GPU-%d '%s'.",
                                    NvCtrlGetTargetId(gpu->handle), gpu->name);
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         goto fail;
     }
 
@@ -3064,7 +3064,7 @@ static Bool layout_add_gpu_from_server(nvLayoutPtr layout, unsigned int gpu_id,
     if (!gpu->handle) {
         *err_str = g_strdup_printf("Failed to create NV-CONTROL handle for "
                                    "GPU-%d.", gpu_id);
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         goto fail;
     }
 
@@ -3077,7 +3077,7 @@ static Bool layout_add_gpu_from_server(nvLayoutPtr layout, unsigned int gpu_id,
     if (ret != NvCtrlSuccess) {
         *err_str = g_strdup_printf("Failed to query GPU name of GPU-%d.",
                                    gpu_id);
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         goto fail;
     }
 
@@ -3088,7 +3088,7 @@ static Bool layout_add_gpu_from_server(nvLayoutPtr layout, unsigned int gpu_id,
     if (ret != NvCtrlSuccess) {
         *err_str = g_strdup_printf("Failed to query MAX SCREEN WIDTH on "
                                    "GPU-%d '%s'.", gpu_id, gpu->name);
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         goto fail;
     }
 
@@ -3097,7 +3097,7 @@ static Bool layout_add_gpu_from_server(nvLayoutPtr layout, unsigned int gpu_id,
     if (ret != NvCtrlSuccess) {
         *err_str = g_strdup_printf("Failed to query MAX SCREEN HEIGHT on "
                                    "GPU-%d '%s'.", gpu_id, gpu->name);
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         goto fail;
     }
 
@@ -3106,7 +3106,7 @@ static Bool layout_add_gpu_from_server(nvLayoutPtr layout, unsigned int gpu_id,
     if (ret != NvCtrlSuccess) {
         *err_str = g_strdup_printf("Failed to query MAX DISPLAYS on "
                                    "GPU-%d '%s'.", gpu_id, gpu->name);
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         goto fail;
     }
 
@@ -3176,7 +3176,7 @@ static int layout_add_gpus_from_server(nvLayoutPtr layout, gchar **err_str)
     if (ret != NvCtrlSuccess || !ngpus) {
         *err_str = g_strdup("Failed to query number of GPUs (or no GPUs "
                             "found) in the system.");
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         goto fail;
     }
 
@@ -3307,7 +3307,7 @@ static Bool layout_add_screen_from_server(nvLayoutPtr layout,
         *err_str = g_strdup_printf("Failed to create NV-CONTROL handle for\n"
                                    "screen %d.",
                                    screen_id);
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         goto fail;
     }
 
@@ -3342,7 +3342,7 @@ static Bool layout_add_screen_from_server(nvLayoutPtr layout,
         *err_str = g_strdup_printf("Failed to query Dynamic TwinView for "
                                    "screen %d.",
                                    screen_id);
-        nv_warning_msg(*err_str);
+        nv_warning_msg("%s", *err_str);
         goto fail;
     }
     screen->dynamic_twinview = !!val;
@@ -3354,7 +3354,7 @@ static Bool layout_add_screen_from_server(nvLayoutPtr layout,
         *err_str = g_strdup_printf("Failed to query NoScanout for "
                                    "screen %d.",
                                    screen_id);
-        nv_warning_msg(*err_str);
+        nv_warning_msg("%s", *err_str);
         goto fail;
     }
     screen->no_scanout = (val == NV_CTRL_NO_SCANOUT_ENABLED);
@@ -3368,7 +3368,7 @@ static Bool layout_add_screen_from_server(nvLayoutPtr layout,
                                    "support scanout screens (%d) that have "
                                    "dynamic twinview disabled.",
                                    screen_id);
-        nv_warning_msg(*err_str);
+        nv_warning_msg("%s", *err_str);
         goto fail;
     }
 
@@ -3376,7 +3376,7 @@ static Bool layout_add_screen_from_server(nvLayoutPtr layout,
     if (!link_screen_to_gpu(layout, screen)) {
         *err_str = g_strdup_printf("Failed to find GPU that drives screen %d.",
                                    screen_id);
-        nv_warning_msg(*err_str);
+        nv_warning_msg("%s", *err_str);
         goto fail;
     }
 
@@ -3475,7 +3475,7 @@ static int layout_add_screens_from_server(nvLayoutPtr layout, gchar **err_str)
     if (ret != NvCtrlSuccess || !nscreens) {
         *err_str = g_strdup("Failed to query number of X screens (or no X "
                             "screens found) in the system.");
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         nscreens = 0;
         goto fail;
     }
@@ -3567,7 +3567,7 @@ nvLayoutPtr layout_load_from_server(NvCtrlAttributeHandle *handle,
                              &layout->xinerama_enabled);
     if (ret != NvCtrlSuccess) {
         *err_str = g_strdup("Failed to query status of Xinerama.");
-        nv_error_msg(*err_str);
+        nv_error_msg("%s", *err_str);
         goto fail;
     }
 
@@ -3580,7 +3580,7 @@ nvLayoutPtr layout_load_from_server(NvCtrlAttributeHandle *handle,
                                    "Display Configuration page.",
                                    displayName ? displayName : "this X server");
         free(displayName);
-        nv_warning_msg(*err_str);
+        nv_warning_msg("%s", *err_str);
         goto fail;
     }
 
diff --git a/src/gtk+-2.x/ctkdisplayconfig.c b/src/gtk+-2.x/ctkdisplayconfig.c
index 10feb75..9845e5b 100644
--- a/src/gtk+-2.x/ctkdisplayconfig.c
+++ b/src/gtk+-2.x/ctkdisplayconfig.c
@@ -717,7 +717,7 @@ static int generate_xconf_metamode_str(CtkDisplayConfig *ctk_object,
             
             parent = ctk_get_parent_window(GTK_WIDGET(ctk_object));
             if (!parent) {
-                nv_warning_msg(msg);
+                nv_warning_msg("%s", msg);
                 g_free(msg);
                 break;
             }
@@ -2209,12 +2209,12 @@ GtkTextBuffer *ctk_display_config_create_help(GtkTextTagTable *table,
                   "down the CONTROL key while clicking on the display, and can "
                   "be moved by holding CONTROL-Click and dragging.");
     ctk_help_heading(b, &i, "Layout Hidden Label");
-    ctk_help_para(b, &i, __layout_hidden_label_help);
+    ctk_help_para(b, &i, "%s", __layout_hidden_label_help);
     ctk_help_heading(b, &i, "Enable Xinerama");
     ctk_help_para(b, &i, "%s  This setting is only available when multiple "
                   "X screens are present.", __layout_xinerama_button_help);
     ctk_help_heading(b, &i, "Selection");
-    ctk_help_para(b, &i, __selected_item_help);
+    ctk_help_para(b, &i, "%s", __selected_item_help);
 
     ctk_help_para(b, &i, "");
     ctk_help_heading(b, &i, "Display Options");
@@ -2222,7 +2222,7 @@ GtkTextBuffer *ctk_display_config_create_help(GtkTextTagTable *table,
                   "device is selected in the Selection drop-down to configure "
                   "the settings for that display device.");
     ctk_help_heading(b, &i, "Resolution");
-    ctk_help_para(b, &i, __dpy_resolution_mnu_help);
+    ctk_help_para(b, &i, "%s", __dpy_resolution_mnu_help);
     ctk_help_heading(b, &i, "Refresh");
     ctk_help_para(b, &i, "The Refresh drop-down is to the right of the "
                   "Resolution drop-down.  %s", __dpy_refresh_mnu_help);
@@ -2231,7 +2231,7 @@ GtkTextBuffer *ctk_display_config_create_help(GtkTextTagTable *table,
                   "currently chosen for the selected display device.  "
                   "This is only available when advanced view is enabled.");
     ctk_help_heading(b, &i, "Stereo Eye");
-    ctk_help_para(b, &i, __dpy_stereo_help);
+    ctk_help_para(b, &i, "%s", __dpy_stereo_help);
     ctk_help_heading(b, &i, "Orientation");
     ctk_help_para(b, &i, "The Orientation drop-downs control how the desktop "
                   "image is rotated and/or reflected.  %s  %s  Note that "
@@ -2243,20 +2243,20 @@ GtkTextBuffer *ctk_display_config_create_help(GtkTextTagTable *table,
                   "size.  This feature is formerly known as Overscan "
                   "Compensation.", __dpy_underscan_text_help);
     ctk_help_heading(b, &i, "Position Type");
-    ctk_help_para(b, &i, __dpy_position_type_help);
+    ctk_help_para(b, &i, "%s", __dpy_position_type_help);
     ctk_help_heading(b, &i, "Position Relative");
-    ctk_help_para(b, &i, __dpy_position_relative_help);
+    ctk_help_para(b, &i, "%s", __dpy_position_relative_help);
     ctk_help_heading(b, &i, "Position Offset");
-    ctk_help_para(b, &i, __dpy_position_offset_help);
+    ctk_help_para(b, &i, "%s", __dpy_position_offset_help);
     ctk_help_heading(b, &i, "ViewPortIn");
-    ctk_help_para(b, &i, __dpy_viewport_in_help);
+    ctk_help_para(b, &i, "%s", __dpy_viewport_in_help);
     ctk_help_heading(b, &i, "ViewPortOut");
-    ctk_help_para(b, &i, __dpy_viewport_out_help);
+    ctk_help_para(b, &i, "%s", __dpy_viewport_out_help);
     ctk_help_heading(b, &i, "Panning");
     ctk_help_para(b, &i, "%s  This is only available when advanced "
                   "view is enabled.", __dpy_panning_help);
     ctk_help_heading(b, &i, "Primary Display");
-    ctk_help_para(b, &i, __dpy_primary_help);
+    ctk_help_para(b, &i, "%s", __dpy_primary_help);
 
 
     ctk_help_para(b, &i, "");
@@ -2269,15 +2269,15 @@ GtkTextBuffer *ctk_display_config_create_help(GtkTextTagTable *table,
                   "304x200, and the width must be a multiple of 8.",
                   __screen_virtual_size_help);
     ctk_help_heading(b, &i, "Color Depth");
-    ctk_help_para(b, &i, __screen_depth_help);
+    ctk_help_para(b, &i, "%s", __screen_depth_help);
     ctk_help_heading(b, &i, "Stereo Mode");
-    ctk_help_para(b, &i, __screen_stereo_help);
+    ctk_help_para(b, &i, "%s", __screen_stereo_help);
     ctk_help_heading(b, &i, "Position Type");
-    ctk_help_para(b, &i, __screen_position_type_help);
+    ctk_help_para(b, &i, "%s", __screen_position_type_help);
     ctk_help_heading(b, &i, "Position Relative");
-    ctk_help_para(b, &i, __screen_position_relative_help);
+    ctk_help_para(b, &i, "%s", __screen_position_relative_help);
     ctk_help_heading(b, &i, "Position Offset");
-    ctk_help_para(b, &i, __screen_position_offset_help);
+    ctk_help_para(b, &i, "%s", __screen_position_offset_help);
     ctk_help_heading(b, &i, "MetaMode Selection");
     ctk_help_para(b, &i, "%s  This is only available when advanced view "
                   "is enabled.", __screen_metamode_help);
@@ -2300,16 +2300,16 @@ GtkTextBuffer *ctk_display_config_create_help(GtkTextTagTable *table,
                   "screen, adding/removing an X screen, and changing the X "
                   "screen color depth.", __apply_button_help);
     ctk_help_heading(b, &i, "Detect Displays");
-    ctk_help_para(b, &i, __detect_displays_button_help);
+    ctk_help_para(b, &i, "%s", __detect_displays_button_help);
     ctk_help_heading(b, &i, "Advanced/Basic...");
     ctk_help_para(b, &i, "%s  The Basic view modifies the currently active "
                   "MetaMode for an X screen, while the advanced view exposes "
                   "all the MetaModes available on an X screen, and lets you "
                   "modify each of them.", __advanced_button_help);
     ctk_help_heading(b, &i, "Reset");
-    ctk_help_para(b, &i, __reset_button_help);
+    ctk_help_para(b, &i, "%s", __reset_button_help);
     ctk_help_heading(b, &i, "Save to X Configuration File");
-    ctk_help_para(b, &i, __save_button_help);
+    ctk_help_para(b, &i, "%s", __save_button_help);
 
     ctk_help_finish(b);
 
@@ -5856,7 +5856,7 @@ static void display_config_changed(GtkWidget *widget, gpointer user_data)
                                   "", &tokens);
             update = TRUE;
             if (!display_add_modelines_from_server(display, display->gpu, &err_str)) {
-                nv_warning_msg(err_str);
+                nv_warning_msg("%s", err_str);
                 g_free(err_str);
                 return;
             }
@@ -8936,7 +8936,7 @@ static void reset_layout(CtkDisplayConfig *ctk_object)
     /* Handle errors loading the new layout */
     if (!layout || err_str) {
         if (err_str) {
-            nv_error_msg(err_str);
+            nv_error_msg("%s", err_str);
             g_free(err_str);
         }
         return;
diff --git a/src/gtk+-2.x/ctkdisplaydevice.c b/src/gtk+-2.x/ctkdisplaydevice.c
index 0202c40..f979e6d 100644
--- a/src/gtk+-2.x/ctkdisplaydevice.c
+++ b/src/gtk+-2.x/ctkdisplaydevice.c
@@ -507,15 +507,15 @@ GtkTextBuffer *ctk_display_device_create_help(GtkTextTagTable *table,
     ctk_help_title(b, &i, "%s Help", ctk_object->name);
 
     ctk_help_heading(b, &i, "Device Information");
-    ctk_help_para(b, &i, __info_help);
+    ctk_help_para(b, &i, "%s", __info_help);
 
     for (j = 0; j < ARRAY_LEN(__info_entry_data); j++) {
         InfoEntryData *entryData = __info_entry_data+j;
         InfoEntry *entry = ctk_object->info_entries+j;
 
         if (entry->present) {
-            ctk_help_term(b, &i, entryData->str);
-            ctk_help_para(b, &i, *entryData->tooltip);
+            ctk_help_term(b, &i, "%s", entryData->str);
+            ctk_help_para(b, &i, "%s", *entryData->tooltip);
         }
     }
 
diff --git a/src/gtk+-2.x/ctkditheringcontrols.c b/src/gtk+-2.x/ctkditheringcontrols.c
index 46431c9..cb4e391 100644
--- a/src/gtk+-2.x/ctkditheringcontrols.c
+++ b/src/gtk+-2.x/ctkditheringcontrols.c
@@ -879,16 +879,16 @@ void add_dithering_controls_help(CtkDitheringControls *ctk_dithering_controls,
     }
 
     ctk_help_heading(b, i, "Dithering Controls");
-    ctk_help_para(b, i, __dithering_help);
+    ctk_help_para(b, i, "%s", __dithering_help);
 
     ctk_help_term(b, i, "Dithering");
-    ctk_help_para(b, i, __dithering_config_help);
+    ctk_help_para(b, i, "%s", __dithering_config_help);
 
     ctk_help_term(b, i, "Mode");
-    ctk_help_para(b, i, __dithering_mode_help);
+    ctk_help_para(b, i, "%s", __dithering_mode_help);
 
     ctk_help_term(b, i, "Depth");
-    ctk_help_para(b, i, __dithering_depth_help);
+    ctk_help_para(b, i, "%s", __dithering_depth_help);
 } /* add_dithering_controls_help() */
 
 
diff --git a/src/gtk+-2.x/ctkecc.c b/src/gtk+-2.x/ctkecc.c
index 7aa3933..04127ad 100644
--- a/src/gtk+-2.x/ctkecc.c
+++ b/src/gtk+-2.x/ctkecc.c
@@ -207,7 +207,7 @@ static void post_ecc_configuration_update(CtkEcc *ctk_ecc)
         snprintf(message, sizeof(message), "ECC %s.", conf_string);
     }
 
-    ctk_config_statusbar_message(ctk_ecc->ctk_config, message);
+    ctk_config_statusbar_message(ctk_ecc->ctk_config, "%s", message);
 } /* post_ecc_configuration_update() */
 
 
@@ -677,36 +677,36 @@ GtkTextBuffer *ctk_ecc_create_help(GtkTextTagTable *table,
     gtk_text_buffer_get_iter_at_offset(b, &i, 0);
 
     ctk_help_heading(b, &i, "ECC Settings Help");
-    ctk_help_para(b, &i, __ecc_settings_help);
+    ctk_help_para(b, &i, "%s", __ecc_settings_help);
     
     ctk_help_heading(b, &i, "ECC");
-    ctk_help_para(b, &i, __ecc_status_help);
+    ctk_help_para(b, &i, "%s", __ecc_status_help);
 
     if (ctk_ecc->dbit_error_available) {
         ctk_help_heading(b, &i, "Double-bit ECC Errors");
-        ctk_help_para(b, &i, __dbit_error_help);
+        ctk_help_para(b, &i, "%s", __dbit_error_help);
     }
     if (ctk_ecc->aggregate_dbit_error_available) {
         ctk_help_heading(b, &i, "Aggregate Double-bit ECC Errors");
-        ctk_help_para(b, &i, __aggregate_dbit_error_help);
+        ctk_help_para(b, &i, "%s", __aggregate_dbit_error_help);
     }
     ctk_help_heading(b, &i, "ECC Configuration");
-    ctk_help_para(b, &i, __configuration_status_help);
+    ctk_help_para(b, &i, "%s", __configuration_status_help);
 
     ctk_help_heading(b, &i, "Enable ECC");
-    ctk_help_para(b, &i, __ecc_status_help);
+    ctk_help_para(b, &i, "%s", __ecc_status_help);
 
     if (ctk_ecc->dbit_error_available) {
         ctk_help_heading(b, &i, "Clear ECC Errors");
-        ctk_help_para(b, &i, __clear_button_help);
+        ctk_help_para(b, &i, "%s", __clear_button_help);
     }
     if (ctk_ecc->aggregate_dbit_error_available) {
         ctk_help_heading(b, &i, "Clear Aggregate ECC Errors");
-        ctk_help_para(b, &i, __clear_aggregate_button_help);
+        ctk_help_para(b, &i, "%s", __clear_aggregate_button_help);
     }
     
     ctk_help_heading(b, &i, "Reset Default Configuration");
-    ctk_help_para(b, &i, __reset_default_config_button_help);
+    ctk_help_para(b, &i, "%s", __reset_default_config_button_help);
 
     ctk_help_finish(b);
 
diff --git a/src/gtk+-2.x/ctkedid.c b/src/gtk+-2.x/ctkedid.c
index e2e0bc6..1e2cf9a 100644
--- a/src/gtk+-2.x/ctkedid.c
+++ b/src/gtk+-2.x/ctkedid.c
@@ -421,6 +421,6 @@ static gboolean write_edid_to_file(CtkConfig *ctk_config, const gchar *filename,
 void add_acquire_edid_help(GtkTextBuffer *b, GtkTextIter *i)
 {
     ctk_help_heading(b, i, "Acquire EDID");
-    ctk_help_para(b, i, __acquire_edid_help);
+    ctk_help_para(b, i, "%s", __acquire_edid_help);
 
 } /* add_acquire_edid_help() */
diff --git a/src/gtk+-2.x/ctkframelock.c b/src/gtk+-2.x/ctkframelock.c
index 68c48f7..5454646 100644
--- a/src/gtk+-2.x/ctkframelock.c
+++ b/src/gtk+-2.x/ctkframelock.c
@@ -5963,8 +5963,8 @@ GtkTextBuffer *ctk_framelock_create_help(GtkTextTagTable *table)
                   "device should behave in the frame lock group.  Setting  of "
                   "options is only available while frame lock is disabled.  "
                   "The following options are available:");
-    ctk_help_para(b, &i, __server_checkbox_help);
-    ctk_help_para(b, &i, __client_checkbox_help);
+    ctk_help_para(b, &i, "%s", __server_checkbox_help);
+    ctk_help_para(b, &i, "%s", __client_checkbox_help);
     ctk_help_para(b, &i, "Stereo LED: This indicates whether or not the "
                   "display device is synced to the stereo signal coming from "
                   "the Quadro Sync device.  This LED is only available to "
@@ -5973,13 +5973,13 @@ GtkTextBuffer *ctk_framelock_create_help(GtkTextTagTable *table)
                   "with the input timing signal.");
 
     ctk_help_heading(b, &i, "Adding Devices");
-    ctk_help_para(b, &i, __add_devices_button_help);
+    ctk_help_para(b, &i, "%s", __add_devices_button_help);
     ctk_help_para(b, &i, "If the X Server is remote, be sure you have "
                   "configured remote access (via `xhost`, for example) "
                   "such that you are allowed to establish a connection.");
     
     ctk_help_heading(b, &i, "Removing Devices");
-    ctk_help_para(b, &i, __remove_devices_button_help);
+    ctk_help_para(b, &i, "%s", __remove_devices_button_help);
 
     /* House Sync Frame Help */
 
@@ -5991,17 +5991,17 @@ GtkTextBuffer *ctk_framelock_create_help(GtkTextTagTable *table)
                   "device (See Display Device Information above.");
 
     ctk_help_heading(b, &i, "Use House Sync on Server");
-    ctk_help_para(b, &i, __use_house_sync_button_help);
+    ctk_help_para(b, &i, "%s", __use_house_sync_button_help);
     ctk_help_para(b, &i, "If this option is checked and no house signal "
                   "is detected (House LED is red), the Quadro Sync device "
                   "will fall back to using internal timings from the primary "
                   "GPU.");
 
     ctk_help_heading(b, &i, "Sync Interval");
-    ctk_help_para(b, &i, __sync_interval_scale_help);
+    ctk_help_para(b, &i, "%s", __sync_interval_scale_help);
 
     ctk_help_heading(b, &i, "Sync Edge");
-    ctk_help_para(b, &i, __sync_edge_combo_help);
+    ctk_help_para(b, &i, "%s", __sync_edge_combo_help);
     ctk_help_para(b, &i, "Syncing to the rising (leading) edge should be "
                   "suitable for bi-level and TTL signals.  Syncing to the "
                   "falling edge should be used for tri-level signals.  "
@@ -6010,10 +6010,10 @@ GtkTextBuffer *ctk_framelock_create_help(GtkTextTagTable *table)
                   "only.");
 
     ctk_help_heading(b, &i, "Video Mode");
-    ctk_help_para(b, &i, __video_mode_help);
+    ctk_help_para(b, &i, "%s", __video_mode_help);
 
     ctk_help_heading(b, &i, "Video Mode Detect");
-    ctk_help_para(b, &i, __detect_video_mode_button_help);
+    ctk_help_para(b, &i, "%s", __detect_video_mode_button_help);
 
     /* Button Help */
     
@@ -6026,7 +6026,7 @@ GtkTextBuffer *ctk_framelock_create_help(GtkTextTagTable *table)
                   "be changed until you disable Test Link.");
 
     ctk_help_heading(b, &i, "Enable Frame Lock");
-    ctk_help_para(b, &i, __sync_enable_button_help);
+    ctk_help_para(b, &i, "%s", __sync_enable_button_help);
     ctk_help_para(b, &i, "Only devices selected as clients or server will be "
                   "enabled.");
 
diff --git a/src/gtk+-2.x/ctkglx.c b/src/gtk+-2.x/ctkglx.c
index 28b8544..7a13cbc 100644
--- a/src/gtk+-2.x/ctkglx.c
+++ b/src/gtk+-2.x/ctkglx.c
@@ -945,7 +945,7 @@ GtkTextBuffer *ctk_glx_create_help(GtkTextTagTable *table,
                  );
 
     ctk_help_heading(b, &i, "Show GLX Frame Buffer Configurations");
-    ctk_help_para(b, &i, __show_fbc_help);
+    ctk_help_para(b, &i, "%s", __show_fbc_help);
 
     ctk_help_heading(b, &i, "GLX Frame Buffer Configurations");
     ctk_help_para(b, &i, "This table lists the supported frame buffer "
diff --git a/src/gtk+-2.x/ctkgvo-csc.c b/src/gtk+-2.x/ctkgvo-csc.c
index cbd1cc3..0f4400f 100644
--- a/src/gtk+-2.x/ctkgvo-csc.c
+++ b/src/gtk+-2.x/ctkgvo-csc.c
@@ -1245,10 +1245,10 @@ GtkTextBuffer *ctk_gvo_csc_create_help(GtkTextTagTable *table,
                   "the SDI (GVO) color space conversion.");
 
     ctk_help_heading(b, &i, "Override default Color Space Conversion");
-    ctk_help_para(b, &i, __override_help);
+    ctk_help_para(b, &i, "%s", __override_help);
 
     ctk_help_heading(b, &i, "Initialize Color Space Conversion");
-    ctk_help_para(b, &i, __initialize_help);
+    ctk_help_para(b, &i, "%s", __initialize_help);
 
     ctk_help_heading(b, &i, "Color Space Conversion Matrix, Offset and Scale");
     ctk_help_para(b, &i, "%s  RGB color is converted to YCrCb in the "
@@ -1282,11 +1282,11 @@ GtkTextBuffer *ctk_gvo_csc_create_help(GtkTextTagTable *table,
 
     if (ctk_gvo_csc->caps & NV_CTRL_GVO_CAPABILITIES_APPLY_CSC_IMMEDIATELY) {
         ctk_help_heading(b, &i, "Apply Changes Immediately");
-        ctk_help_para(b, &i, __apply_immediately_help);
+        ctk_help_para(b, &i, "%s", __apply_immediately_help);
     }
 
     ctk_help_heading(b, &i, "Apply");
-    ctk_help_para(b, &i, __apply_help);
+    ctk_help_para(b, &i, "%s", __apply_help);
 
     ctk_help_finish(b);
 
diff --git a/src/gtk+-2.x/ctkgvo-sync.c b/src/gtk+-2.x/ctkgvo-sync.c
index 90902b8..ac75521 100644
--- a/src/gtk+-2.x/ctkgvo-sync.c
+++ b/src/gtk+-2.x/ctkgvo-sync.c
@@ -1502,30 +1502,30 @@ GtkTextBuffer* ctk_gvo_sync_create_help(GtkTextTagTable *table,
                   "SDI synchronization options.");
 
     ctk_help_heading(b, &i, "Input Video Format");
-    ctk_help_para(b, &i, __input_video_format_help);
+    ctk_help_para(b, &i, "%s", __input_video_format_help);
     ctk_help_heading(b, &i, "Input Video Format Detect");
-    ctk_help_para(b, &i, __input_video_format_detect_help);
+    ctk_help_para(b, &i, "%s", __input_video_format_detect_help);
     ctk_help_heading(b, &i, "Composite Termination");
     ctk_help_para(b, &i, "%s.  This allows the composite signal to be daisy "
                   "chained from a server load.",
                   __composite_termination_help);
     ctk_help_heading(b, &i, "Sync Mode");
-    ctk_help_para(b, &i, __sync_mode_help);
+    ctk_help_para(b, &i, "%s", __sync_mode_help);
     ctk_help_heading(b, &i, "Sync Format");
-    ctk_help_para(b, &i, __sync_format_help);
+    ctk_help_para(b, &i, "%s", __sync_format_help);
     ctk_help_heading(b, &i, "Sync Status");
-    ctk_help_para(b, &i, __sync_status_help);
+    ctk_help_para(b, &i, "%s", __sync_status_help);
 
     if ( ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_ADVANCE_SYNC_SKEW ) {
         ctk_help_heading(b, &i, "HSync Advance");
-        ctk_help_para(b, &i, __hsync_advance_help);
+        ctk_help_para(b, &i, "%s", __hsync_advance_help);
         ctk_help_heading(b, &i, "VSync Advance");
-        ctk_help_para(b, &i, __vsync_advance_help);
+        ctk_help_para(b, &i, "%s", __vsync_advance_help);
     } else {
         ctk_help_heading(b, &i, "HSync Delay");
-        ctk_help_para(b, &i, __hsync_delay_help);
+        ctk_help_para(b, &i, "%s", __hsync_delay_help);
         ctk_help_heading(b, &i, "VSync Delay");
-        ctk_help_para(b, &i, __vsync_delay_help);
+        ctk_help_para(b, &i, "%s", __vsync_delay_help);
     }
 
     ctk_help_finish(b);
diff --git a/src/gtk+-2.x/ctkgvo.c b/src/gtk+-2.x/ctkgvo.c
index 425159b..f833bcd 100644
--- a/src/gtk+-2.x/ctkgvo.c
+++ b/src/gtk+-2.x/ctkgvo.c
@@ -783,16 +783,16 @@ GtkTextBuffer* ctk_gvo_create_help(GtkTextTagTable *table)
     ctk_help_para(b, &i, "This section shows information about the SDI device "
                   "that is associated with the X screen.");
     ctk_help_heading(b, &i, "Firmware Version");
-    ctk_help_para(b, &i, __general_firmware_version_help);
+    ctk_help_para(b, &i, "%s", __general_firmware_version_help);
     ctk_help_heading(b, &i, "Current SDI Resolution");
-    ctk_help_para(b, &i, __general_current_sdi_resolution_help);
+    ctk_help_para(b, &i, "%s", __general_current_sdi_resolution_help);
     ctk_help_heading(b, &i, "Current SDI State");
-    ctk_help_para(b, &i, __general_current_sdi_state_help);
+    ctk_help_para(b, &i, "%s", __general_current_sdi_state_help);
 
     ctk_help_heading(b, &i, "Requested SDI Video Format");
-    ctk_help_para(b, &i, __requested_sdi_video_format_help);
+    ctk_help_para(b, &i, "%s", __requested_sdi_video_format_help);
     ctk_help_heading(b, &i, "Requested SDI Data Format");
-    ctk_help_para(b, &i, __requested_sdi_data_format_help);
+    ctk_help_para(b, &i, "%s", __requested_sdi_data_format_help);
 
     ctk_help_finish(b);
 
diff --git a/src/gtk+-2.x/ctkhelp.c b/src/gtk+-2.x/ctkhelp.c
index 9a4ac0a..d2d9efa 100644
--- a/src/gtk+-2.x/ctkhelp.c
+++ b/src/gtk+-2.x/ctkhelp.c
@@ -414,7 +414,7 @@ void ctk_help_reset_hardware_defaults(GtkTextBuffer *b, GtkTextIter *i,
                                       gchar *text)
 {
     ctk_help_heading(b, i, "Reset Hardware Defaults");
-    ctk_help_para(b, i, text);
+    ctk_help_para(b, i, "%s", text);
 }
 
 
@@ -463,16 +463,16 @@ static void help_data_list_print_helper(GtkTextBuffer *b,
     for (cur = help_data_list; cur; cur = cur->next) {
         item = (CtkHelpDataItem *)cur->data;
         if (use_headings) {
-            ctk_help_heading(b, i, item->label);
+            ctk_help_heading(b, i, "%s", item->label);
         } else {
-            ctk_help_term(b, i, item->label);
+            ctk_help_term(b, i, "%s", item->label);
         }
         g_string_printf(temp_string, "%s", item->help_text);
         if (item->extended_help_text) {
             g_string_append_printf(temp_string, " %s",
                                    item->extended_help_text);
         }
-        ctk_help_para(b, i, temp_string->str);
+        ctk_help_para(b, i, "%s", temp_string->str);
     }
 
     g_string_free(temp_string, TRUE);
diff --git a/src/gtk+-2.x/ctkmultisample.c b/src/gtk+-2.x/ctkmultisample.c
index ad3b30e..d179de6 100644
--- a/src/gtk+-2.x/ctkmultisample.c
+++ b/src/gtk+-2.x/ctkmultisample.c
@@ -1524,7 +1524,7 @@ GtkTextBuffer *ctk_multisample_create_help(GtkTextTagTable *table,
         ctk_help_term(b, &i, "Application Antialiasing Settings");
         
         if (ctk_multisample->active_attributes & __FSAA_ENHANCE) {
-            ctk_help_para(b, &i, __aa_menu_help);
+            ctk_help_para(b, &i, "%s", __aa_menu_help);
             ctk_help_para(b, &i, "Use Application Settings will let applications "
                           "choose the AA mode.");
             ctk_help_para(b, &i, "Override Application Settings will override "
@@ -1535,7 +1535,7 @@ GtkTextBuffer *ctk_multisample_create_help(GtkTextTagTable *table,
                           "antialiasing mode use the mode selected by the "
                           "slider.");
         } else {
-            ctk_help_para(b, &i, __aa_override_app_help);
+            ctk_help_para(b, &i, "%s", __aa_override_app_help);
         }
 
         if (ctk_multisample->active_attributes & __FSAA_NONE) {
@@ -1647,7 +1647,7 @@ GtkTextBuffer *ctk_multisample_create_help(GtkTextTagTable *table,
 
     if (ctk_multisample->active_attributes & __FXAA) {
         ctk_help_term(b, &i, "Enable FXAA");
-        ctk_help_para(b, &i, __fxaa_enable_help);
+        ctk_help_para(b, &i, "%s", __fxaa_enable_help);
     }
 
     if (ctk_multisample->active_attributes & __LOG_ANISO_RANGE) {
@@ -1669,14 +1669,14 @@ GtkTextBuffer *ctk_multisample_create_help(GtkTextTagTable *table,
         
         ctk_help_term(b, &i, "Override Application Setting");
         
-        ctk_help_para(b, &i, __aniso_override_app_help);
+        ctk_help_para(b, &i, "%s", __aniso_override_app_help);
         
-        ctk_help_para(b, &i, __aniso_slider_help);
+        ctk_help_para(b, &i, "%s", __aniso_slider_help);
     }
 
     if (ctk_multisample->active_attributes & __TEXTURE_SHARPEN) {
         ctk_help_heading(b, &i, "Texture Sharpening");
-        ctk_help_para(b, &i, __texture_sharpening_help);
+        ctk_help_para(b, &i, "%s", __texture_sharpening_help);
     }
 
     ctk_help_finish(b);
diff --git a/src/gtk+-2.x/ctkopengl.c b/src/gtk+-2.x/ctkopengl.c
index f0a2e83..d9b37d7 100644
--- a/src/gtk+-2.x/ctkopengl.c
+++ b/src/gtk+-2.x/ctkopengl.c
@@ -1206,7 +1206,7 @@ GtkTextBuffer *ctk_opengl_create_help(GtkTextTagTable *table,
 
     if (ctk_opengl->active_attributes & __SYNC_TO_VBLANK) {
         ctk_help_heading(b, &i, "Sync to VBlank");
-        ctk_help_para(b, &i, __sync_to_vblank_help);
+        ctk_help_para(b, &i, "%s", __sync_to_vblank_help);
     }
 
     if (ctk_opengl->active_attributes & __ALLOW_FLIPPING) {
@@ -1228,17 +1228,17 @@ GtkTextBuffer *ctk_opengl_create_help(GtkTextTagTable *table,
 
     if (ctk_opengl->active_attributes & __FORCE_STEREO) {
         ctk_help_heading(b, &i, "Force Stereo Flipping");
-        ctk_help_para(b, &i, __force_stereo_help);
+        ctk_help_para(b, &i, "%s", __force_stereo_help);
     }
     
     if (ctk_opengl->active_attributes & __XINERAMA_STEREO) {
         ctk_help_heading(b, &i, "Allow Xinerama Stereo Flipping");
-        ctk_help_para(b, &i, __xinerama_stereo_help);
+        ctk_help_para(b, &i, "%s", __xinerama_stereo_help);
     }
     
     if (ctk_opengl->active_attributes & __STEREO_EYES_EXCHANGE) {
         ctk_help_heading(b, &i, "Exchange Stereo Eyes");
-        ctk_help_para(b, &i, __stereo_eyes_exchange_help);
+        ctk_help_para(b, &i, "%s", __stereo_eyes_exchange_help);
     }
     
     if (ctk_opengl->active_attributes & __IMAGE_SETTINGS) {
@@ -1277,18 +1277,18 @@ GtkTextBuffer *ctk_opengl_create_help(GtkTextTagTable *table,
     if (ctk_opengl->active_attributes & __AA_LINE_GAMMA) {
         ctk_help_heading(b, &i, "Enable gamma correction for "
                          "antialiased lines");
-        ctk_help_para(b, &i, __aa_line_gamma_checkbox_help );
+        ctk_help_para(b, &i, "%s", __aa_line_gamma_checkbox_help );
     }
 
     if (ctk_opengl->active_attributes & __AA_LINE_GAMMA_VALUE) {
         ctk_help_heading(b, &i, "Set gamma correction for "
                          "antialiased lines");
-        ctk_help_para(b, &i, __aa_line_gamma_slider_help);
+        ctk_help_para(b, &i, "%s", __aa_line_gamma_slider_help);
     }
 
     if (ctk_opengl->active_attributes & __CONFORMANT_CLAMPING) {
         ctk_help_heading(b, &i, "Use Conformant Texture Clamping");
-        ctk_help_para(b, &i, __use_conformant_clamping_help);
+        ctk_help_para(b, &i, "%s", __use_conformant_clamping_help);
     }
 
     if (ctk_opengl->active_attributes & __SHOW_SLI_VISUAL_INDICATOR) {
diff --git a/src/gtk+-2.x/ctkpowermizer.c b/src/gtk+-2.x/ctkpowermizer.c
index f846ec7..1dd12f2 100644
--- a/src/gtk+-2.x/ctkpowermizer.c
+++ b/src/gtk+-2.x/ctkpowermizer.c
@@ -1396,7 +1396,7 @@ static void post_dp_configuration_update(CtkPowermizer *ctk_powermizer)
                  conf_string);
     }
 
-    ctk_config_statusbar_message(ctk_powermizer->ctk_config, message);
+    ctk_config_statusbar_message(ctk_powermizer->ctk_config, "%s", message);
 } /* post_dp_configuration_update() */
 
 
@@ -1527,7 +1527,7 @@ GtkTextBuffer *ctk_powermizer_create_help(GtkTextTagTable *table,
 
     if (ctk_powermizer->adaptive_clock_status) {
         ctk_help_heading(b, &i, "Adaptive Clocking");
-        ctk_help_para(b, &i, __adaptive_clock_help);
+        ctk_help_para(b, &i, "%s", __adaptive_clock_help);
     }
 
     if (ctk_powermizer->gpu_clock) {
@@ -1542,36 +1542,36 @@ GtkTextBuffer *ctk_powermizer_create_help(GtkTextTagTable *table,
         } else {
             s = "This indicates the GPU's current Graphics Clock ferquencies.";
         }
-        ctk_help_para(b, &i, s);
+        ctk_help_para(b, &i, "%s", s);
     }
 
     if (ctk_powermizer->power_source) {
         ctk_help_heading(b, &i, "Power Source");
-        ctk_help_para(b, &i, __power_source_help);
+        ctk_help_para(b, &i, "%s", __power_source_help);
     }
 
     if (ctk_powermizer->pcie_gen_queriable) {
         ctk_help_heading(b, &i, "Current PCIe link width");
-        ctk_help_para(b, &i, __current_pcie_link_width_help);
+        ctk_help_para(b, &i, "%s", __current_pcie_link_width_help);
         ctk_help_heading(b, &i, "Current PCIe link speed");
-        ctk_help_para(b, &i, __current_pcie_link_speed_help);
+        ctk_help_para(b, &i, "%s", __current_pcie_link_speed_help);
     }
 
     if (ctk_powermizer->performance_level) {
         ctk_help_heading(b, &i, "Performance Level");
-        ctk_help_para(b, &i, __performance_level_help);
+        ctk_help_para(b, &i, "%s", __performance_level_help);
         ctk_help_heading(b, &i, "Performance Levels (Table)");
-        ctk_help_para(b, &i, __performance_levels_table_help);
+        ctk_help_para(b, &i, "%s", __performance_levels_table_help);
     }
 
     if (ctk_powermizer->powermizer_menu) {
         ctk_help_heading(b, &i, "PowerMizer Settings");
-        ctk_help_para(b, &i, ctk_powermizer->powermizer_menu_help);
+        ctk_help_para(b, &i, "%s", ctk_powermizer->powermizer_menu_help);
     }
 
     if (ctk_powermizer->configuration_button) {
         ctk_help_heading(b, &i, "CUDA - Double precision");
-        ctk_help_para(b, &i, __dp_configuration_button_help);
+        ctk_help_para(b, &i, "%s", __dp_configuration_button_help);
     }
 
     ctk_help_finish(b);
diff --git a/src/gtk+-2.x/ctkpowersavings.c b/src/gtk+-2.x/ctkpowersavings.c
index fe293ce..1c5ebfe 100644
--- a/src/gtk+-2.x/ctkpowersavings.c
+++ b/src/gtk+-2.x/ctkpowersavings.c
@@ -222,7 +222,7 @@ GtkTextBuffer *ctk_power_savings_create_help(GtkTextTagTable *table,
     ctk_help_title(b, &i, "Power Savings Help");
 
     ctk_help_heading(b, &i, "On-Demand VBlank Interrupts");
-    ctk_help_para(b, &i, __vblank_control_help);
+    ctk_help_para(b, &i, "%s", __vblank_control_help);
 
     ctk_help_finish(b);
 
diff --git a/src/gtk+-2.x/ctkthermal.c b/src/gtk+-2.x/ctkthermal.c
index 92673ac..608efe8 100644
--- a/src/gtk+-2.x/ctkthermal.c
+++ b/src/gtk+-2.x/ctkthermal.c
@@ -1623,32 +1623,32 @@ GtkTextBuffer *ctk_thermal_create_help(GtkTextTagTable *table,
 
     if (!ctk_thermal->thermal_sensor_target_type_supported) {
         ctk_help_heading(b, &i, "Slowdown Threshold");
-        ctk_help_para(b, &i, __core_threshold_help);
+        ctk_help_para(b, &i, "%s", __core_threshold_help);
 
         ctk_help_heading(b, &i, "Core Temperature");
-        ctk_help_para(b, &i, __core_temp_help);
+        ctk_help_para(b, &i, "%s", __core_temp_help);
 
         if (ctk_thermal->ambient_label) {
             ctk_help_heading(b, &i, "Ambient Temperature");
-            ctk_help_para(b, &i, __ambient_temp_help);
+            ctk_help_para(b, &i, "%s", __ambient_temp_help);
         }
     } else {
         ctk_help_title(b, &i, "Thermal Sensor Information Help");
 
         ctk_help_heading(b, &i, "ID");
-        ctk_help_para(b, &i, __thermal_sensor_id_help);
+        ctk_help_para(b, &i, "%s", __thermal_sensor_id_help);
 
         ctk_help_heading(b, &i, "Temperature");
-        ctk_help_para(b, &i, __thermal_sensor_reading_help);
+        ctk_help_para(b, &i, "%s", __thermal_sensor_reading_help);
 
         ctk_help_heading(b, &i, "Target");
-        ctk_help_para(b, &i, __thermal_sensor_target_help);
+        ctk_help_para(b, &i, "%s", __thermal_sensor_target_help);
         
         ctk_help_heading(b, &i, "Provider");
-        ctk_help_para(b, &i, __thermal_sensor_provider_help);
+        ctk_help_para(b, &i, "%s", __thermal_sensor_provider_help);
     }
     ctk_help_heading(b, &i, "Level");
-    ctk_help_para(b, &i, __temp_level_help);
+    ctk_help_para(b, &i, "%s", __temp_level_help);
 
 next_help:
     /* if Fan not available skip online help */
@@ -1659,26 +1659,26 @@ next_help:
     ctk_help_title(b, &i, "GPU Fan Settings Help");
 
     ctk_help_heading(b, &i, "ID");
-    ctk_help_para(b, &i, __fan_id_help);
+    ctk_help_para(b, &i, "%s", __fan_id_help);
 
     ctk_help_heading(b, &i, "Speed (%%)");
-    ctk_help_para(b, &i, __fan_speed_help);
+    ctk_help_para(b, &i, "%s", __fan_speed_help);
 
     ctk_help_heading(b, &i, "Type");
-    ctk_help_para(b, &i, __fan_control_type_help);
+    ctk_help_para(b, &i, "%s", __fan_control_type_help);
 
     ctk_help_heading(b, &i, "Cooling Target");
-    ctk_help_para(b, &i, __fan_cooling_target_help);
+    ctk_help_para(b, &i, "%s", __fan_cooling_target_help);
 
     ctk_help_heading(b, &i, "Enable GPU Fan Settings");
-    ctk_help_para(b, &i, __enable_button_help);
+    ctk_help_para(b, &i, "%s", __enable_button_help);
 
     if ( ctk_thermal->show_fan_control_frame ) {
         ctk_help_heading(b, &i, "Enable GPU Fan Settings");
-        ctk_help_para(b, &i, __apply_button_help);
+        ctk_help_para(b, &i, "%s", __apply_button_help);
 
         ctk_help_heading(b, &i, "Enable GPU Fan Settings");
-        ctk_help_para(b, &i, __reset_button_help);
+        ctk_help_para(b, &i, "%s", __reset_button_help);
     }
 done:
     ctk_help_finish(b);
diff --git a/src/gtk+-2.x/ctkutils.c b/src/gtk+-2.x/ctkutils.c
index a65b411..6a5752a 100644
--- a/src/gtk+-2.x/ctkutils.c
+++ b/src/gtk+-2.x/ctkutils.c
@@ -300,7 +300,7 @@ void ctk_display_error_msg(GtkWidget *parent, gchar * msg)
     GtkWidget *dlg;
     
     if (msg) {
-        nv_error_msg(msg);
+        nv_error_msg("%s", msg);
 
         if (parent) {
             dlg = gtk_message_dialog_new
@@ -328,7 +328,7 @@ void ctk_display_warning_msg(GtkWidget *parent, gchar * msg)
     GtkWidget *dlg;
     
     if (msg) {
-        nv_warning_msg(msg);
+        nv_warning_msg("%s", msg);
 
         if (parent) {
             dlg = gtk_message_dialog_new
diff --git a/src/gtk+-2.x/ctkvdpau.c b/src/gtk+-2.x/ctkvdpau.c
index ac4c388..8415fb2 100644
--- a/src/gtk+-2.x/ctkvdpau.c
+++ b/src/gtk+-2.x/ctkvdpau.c
@@ -454,7 +454,7 @@ static int queryVideoSurface(CtkVDPAU *ctk_vdpau, VdpDevice device,
                     str1 = g_string_append(str1, s);
                 }
             }
-            label = gtk_label_new(g_strdup_printf(str1->str));
+            label = gtk_label_new(g_strdup_printf("%s", str1->str));
             gtk_label_set_selectable(GTK_LABEL(label), TRUE);
             gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
             gtk_table_attach(GTK_TABLE(table), label, 3, 4, count+1, count+2,
@@ -792,7 +792,7 @@ static int queryOutputSurface(CtkVDPAU *ctk_vdpau, VdpDevice device,
                     str1 = g_string_append(str1, s);
                 }
             }
-            label = gtk_label_new(g_strdup_printf(str1->str));
+            label = gtk_label_new(g_strdup_printf("%s", str1->str));
             gtk_label_set_selectable(GTK_LABEL(label), TRUE);
             gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
             gtk_table_attach(GTK_TABLE(table), label, 4, 5, count+1, count+2,
@@ -1541,43 +1541,43 @@ GtkTextBuffer *ctk_vdpau_create_help(GtkTextTagTable *table,
     gtk_text_buffer_get_iter_at_offset(b, &i, 0);
 
     ctk_help_title(b, &i, "VDPAU Information Help");
-    ctk_help_para(b, &i, __vdpau_information_label_help);
+    ctk_help_para(b, &i, "%s", __vdpau_information_label_help);
 
     ctk_help_heading(b, &i, "Base Information");
-    ctk_help_para(b, &i, __base_information_help);
+    ctk_help_para(b, &i, "%s", __base_information_help);
 
     ctk_help_heading(b, &i, "API Version");
-    ctk_help_para(b, &i, __vdpau_api_version_help);
+    ctk_help_para(b, &i, "%s", __vdpau_api_version_help);
 
     ctk_help_heading(b, &i, "Supported Codecs");
-    ctk_help_para(b, &i, __supported_codecs_help);
+    ctk_help_para(b, &i, "%s", __supported_codecs_help);
 
     ctk_help_heading(b, &i, "Surface Limits");
-    ctk_help_para(b, &i, __surface_limits_help);
+    ctk_help_para(b, &i, "%s", __surface_limits_help);
 
     ctk_help_heading(b, &i, "Video Surface");
-    ctk_help_para(b, &i, __video_surface_help);
+    ctk_help_para(b, &i, "%s", __video_surface_help);
 
     ctk_help_heading(b, &i, "Output Surface");
-    ctk_help_para(b, &i, __ouput_surface_help);
+    ctk_help_para(b, &i, "%s", __ouput_surface_help);
 
     ctk_help_heading(b, &i, "Bitmap Surface");
-    ctk_help_para(b, &i, __bitmap_surface_help);
+    ctk_help_para(b, &i, "%s", __bitmap_surface_help);
 
     ctk_help_heading(b, &i, "Decoder Limits");
-    ctk_help_para(b, &i, __decoder_limits_help);
+    ctk_help_para(b, &i, "%s", __decoder_limits_help);
 
     ctk_help_heading(b, &i, "Video Mixer");
-    ctk_help_para(b, &i, __video_mixer_help);
+    ctk_help_para(b, &i, "%s", __video_mixer_help);
 
     ctk_help_term(b, &i, "Feature");
-    ctk_help_para(b, &i, __video_mixer_feature_help);
+    ctk_help_para(b, &i, "%s", __video_mixer_feature_help);
 
     ctk_help_term(b, &i, "Parameter");
-    ctk_help_para(b, &i, __video_mixer_parameter_help);
+    ctk_help_para(b, &i, "%s", __video_mixer_parameter_help);
 
     ctk_help_term(b, &i, "Attribute");
-    ctk_help_para(b, &i, __video_mixer_attribute_help);
+    ctk_help_para(b, &i, "%s", __video_mixer_attribute_help);
 
     ctk_help_finish(b);
     return b;
diff --git a/src/gtk+-2.x/ctkxvideo.c b/src/gtk+-2.x/ctkxvideo.c
index a7f8a4f..aa7d6e3 100644
--- a/src/gtk+-2.x/ctkxvideo.c
+++ b/src/gtk+-2.x/ctkxvideo.c
@@ -532,7 +532,7 @@ GtkTextBuffer *ctk_xvideo_create_help(GtkTextTagTable *table,
     
     if (ctk_xvideo->active_attributes & __XV_SYNC_TO_DISPLAY) {
         ctk_help_heading(b, &i, "Sync to this display device");
-        ctk_help_para(b, &i, __xv_sync_to_display_help);
+        ctk_help_para(b, &i, "%s", __xv_sync_to_display_help);
     }
     
     ctk_help_finish(b);